39-Golang中的接口

news2024/11/18 9:24:11

Golang中的接口

- 基本介绍
- 基本语法
- 注意事项和细节
- 案例
- - 实现对Hero结构体切片的排序：sort.Sort(data Interface)
- 实现接口和继承之间的比较
- - 区别

基本介绍

interface类型可以定义一组方法，但是这些不需要实现。并且interface不能包含任何变量。到某个自定义类型要使用的时候，在根据具体情况把这些方法写出来

基本语法

在这里插入图片描述
说明：

1.接口里的所有方法都没有方法体，即接口的方法都是没有实现的方法。接口体现了程序设计的多态和高内聚低耦合的思想

2.Golang中的接口，不需要显式的实现。只要一个变量，含有接口类型中的所有方法，那么这个变量就实现这个接口。因此，Golang中没有implement这样的关键字。

注意事项和细节

1.接口本身不能创建实例，但是可以指向一个实现了该接口的自定义类型的变量(实例)

在这里插入图片描述

2.接口中所有的方法都没有方法体，即都是没有实现的方法
3.在golang中，一个自定义类型需要将某个接口与的所有方法都实现，则这个自定义类型实现了该接口
4.一个自定义类型只有实现了某个接口，才能将该自定义类型的实例(变量)赋给接口类型
5.只要是自定义数据类型，就可以实现接口，不仅仅是结构体类型

在这里插入图片描述

6.golang接口中不能有任何变量

在这里插入图片描述

7.一个自定义类型可以实现多个接口

在这里插入图片描述

8.一个接口(比如A接口)可以继承多个别的接口(比如B，C接口)，这时如果要实现A接口，也必须将B,C接口分方法也全部实现

package main
import (
	_ "fmt"
)
type BInterface interface {
	test01
}

type CInterface interface {
	test02
}

type AInterface interface {
	BInterface
	CInterface
	test03
}

//如果要事项AInterface，就需要将Binterface，CInterface的方法都实现

type Stu struct {

}
func (stu Stu) test01() {
	
}
func (stu Stu) test02() {

}
func (stu Stu) test03() {

}

func main() {
	var str Stu
	var a AInterface = stu
	a.test01
}

9.interface类型默认是一个指针(引用类型)，如果没有对interface初始化就使用，那么会输出nil
10.空接口interface{}没有任何方法，所以所有类型都实现了空接口，即我们可以把任何一个变量赋给空接口

type T interface{

}
func main() {
	var t T = stu //ok
	fmt.Println(t)
    var t2 interface{} = stu
    var num1 float64 = 8.8
    t2 = num1
    t = num1
    fmt.Println(t2, t)
}

案例

在这里插入图片描述

实现对Hero结构体切片的排序：sort.Sort(data Interface)

package main
import (
	"fmt"
	"sort"
	"math/rand"
)

//1.声明一个hero结构体
type Hero struct {
	Name string
	Age int
}
//2.声明一个Hero结构体切片类型
type HeroSlice []Hero

//3.实现Interface接口，//文档固定的
func (hs HeroSlice) Len() int {
	return len(hs)
}

//less这个方法就是决定是使用什么标准进行排序
//1.按年龄从小到大

func (hs HeroSlice) Less(i, j int) bool {
	return hs[i].Age < hs[j].Age
}

func (hs HeroSlice) Swap(i, j int) {
	temp := hs[i]
	hs[i] = hs[j]
	hs[j] = temp
}

func main() {
	//先定义一个数组/切片
	var intslice = []int{0 , -1, 10, 7, 90}
	//要求对intslice进行排序
	sort.Ints(intslice)
	fmt.Println(intslice)

	//对一个结构体切片进行排序
	var heroes HeroSlice
	for i := 0; i < 10; i++{
		hero := Hero{
			Name :fmt.Sprintf("英雄~%d", rand.Intn(100)),
			Age : rand.Intn(100),
		}
		//将hero append到heroes切片
		heroes = append(heroes, hero)
	}
	//看看排序前的顺序
	for _ , v := range heroes {
		fmt.Println(v)
	}

	//调用sor.tSort
	sort.Sort(heroes)
	fmt.Println("-----------------")
	//看看排序后的顺序
	for _ , v := range heroes {
		fmt.Println(v)
	}

}
/*
[-1 0 7 10 90]
{英雄~81 87}
{英雄~47 59}
{英雄~81 18}
{英雄~25 40}
{英雄~56 0}
{英雄~94 11}
{英雄~62 89}
{英雄~28 74}
{英雄~11 45}
{英雄~37 6}
-----------------
{英雄~56 0}
{英雄~37 6}
{英雄~94 11}
{英雄~81 18}
{英雄~25 40}
{英雄~11 45}
{英雄~47 59}
{英雄~28 74}
{英雄~81 87}
{英雄~62 89}
*/

实现接口和继承之间的比较

1.接口是继承的补充

2.当a结构体继承了b结构体，那么a结构体就自动继承了b结构体的字段和方法，并且可以直接使用

3.当a结构体需要扩展功能，同时不希望去破坏继承关系，则可以去实现某个接口即可

package main 
import (
	"fmt"
)

//monkey结构体
type Monkey struct {
	Name string
}

//声明接口
type BirdAble interface {
	Flying()
}

func (this *Monkey) climbing() {
	fmt.Println(this.Name, "天生会爬树")
}

//littleMonkey结构体
type LittleMonkey struct {
	Monkey //继承
}

//让littlemonkey实现birdable
func (this *LittleMonkey) Flying() {
	fmt.Println(this.Name, "通过学习学会飞")
}

func main() {
	//差UN交啊ing一个littlemonkey 实例
	monkey := LittleMonkey{
		Monkey {
			Name : "悟空",
		},
	}
	monkey.climbing()
	monkey.Flying()
}
//悟空 天生会爬树
//悟空 通过学习学会飞