Go语言之路————接口、泛型

前言

• 我是一名多年Java开发人员，因为工作需要现在要学习go语言，Go语言之路是一个系列，记录着我从0开始接触Go，到后面能正常完成工作上的业务开发的过程，如果你也是个小白或者转Go语言的，希望我这篇文章对你有所帮助。
• 有关go其他基础的内容的文章大家可以查看我的主页，接下来主要就是把这个系列更完，更完之后我会在每篇文章中挂上连接，方便大家跳转和复习。

接口定义

什么是接口？如果有学过Java的，你就把它和Java的接口类比就行，相似度很高，没有学过的我们就看看官方定义
1.18之前
定义：一组方法的集合
实现：当一个类型的方法集是一个接口的方法集的超集时，且该类型的值可以由该接口类型的变量存储，那么称该类型实现了该接口
1.18之后
定义：一组类型的集合
实现：当一个类型位于一个接口的类型集内，且该类型的值可以由该接口类型的变量存储，那么称该类型实现了该接口
为啥会在这个版本之间有差别，因为go的1.18版本是个很大的分水岭，这个版本引入了很多新东西，影响接口定义的就是泛型，大家可以理解为jdk8版本这一划时代的影响。

官方文档的定义和实现苦涩难懂，但是官方的东西大家懂的都懂，鸟用没有全是一些很官方的话，你可以不用去理解上面这一大段东西，你只需要知道一个类型实现接口A的所有方法，那么就称这个类型实现了这个接口，跟Java差不多

实操，接口的定义和实现

说了那么多来点实在的，go中结构的定义和Java一样，还是用interface，下面我们看下一个简单的接口定义：

type Animal interface {Shut() string
}

那么怎么去实现接口：

type Dog struct {
}func (receiver Dog) Shut() string {return "汪汪汪"
}

我们创建一个Dog的结构体，它有一个方法Shut，刚好Animal 接口也只有一个方法Shut，这样我们就称Dog实现了Animal 接口，就这么简单。
验证下：

func main() {animals := []Animal{Dog{}}for _, a := range animals {fmt.Println(a.Shut())}
}
console：
汪汪汪

我们创建一个Animal类型的切片，里面放入Dog结构体，因为Dog实现了Animal接口，所以他们类型一样，可以正常编码。

接口的继承

任何自定义类型都可以拥有方法，那么根据实现的定义，任何自定义类型都可以实现接口，那么接口也可以实现接口，这就相当于Java中的继承，用法一个样，看我举例说明：

type Animal interface {Shut() string
}
type Dog interface {AA() stringAnimal
}

我们上面定义了Animal 的接口，表示动物这一种类，但是我现在还想细分一下，动物很多种，我这里再定义一个狗的接口，实现了Animal 的接口，只需要在Dog的接口字段中声明Animal ，这就实现了继承
我再创建一个结构体二哈，表示狗的一个种类

type ErHa struct {
}func (receiver ErHa) Shut() string {return "汪汪汪"
}func (receiver ErHa) AA() string {return "二哈"
}

注意，这里的EeHa一定要实现Dog 和Animal 的所有方法，不然会报错。
然后验证一下：

func main() {animals := []Animal{ErHa{}}dogs := []Dog{ErHa{}}for _, a := range animals {fmt.Println(a.Shut())}for _, a := range dogs {fmt.Println(a.Shut())}
}
console打印：
汪汪汪
汪汪汪

由此可见，二哈既可以转成他的父类Dog，又可以转成他的爷爷类Animal，这就是接口的特性。

空接口和Any

go中所有类型都是Any接口的的实现，相当于Java的Object，我们点进any看，其实它就是一个空接口

type any = interface{}

泛型

一句话，跟Java的定义一样，只是写法不一样
因为go在1.18后才支持泛型，所有使用的时候要指定go的版本，在go.mod文件中添加如下一行：

go 1.18

然后我们看看代码示例：

import "fmt"func testGeneric[T int | string](a, b T) {fmt.Println(a, b)
}func main() {testGeneric(1, 1)
}console打印：
1 1

我来详细解释一下，新建一个函数test
1.test后面的花括号里面的东西：[T int | string]，这是泛型的约束，T代表类型形参，具体啥类型是传进来的，包括后面的参数：(a, b T)，这个T和前面的是一个东西，T可以用其他任何字母代替，不是非要用T，你可以用A，可以用K
2.int | string：这个是一个类型约束，代表T的类型可以有哪些，比如我这里写的int和string，就代表T只能是int或者string类型的数据，当然还可以扩展：int | string | float，竖线分隔就行。

下面是一个泛型的切片：

type GenericSlice[T int | int32 | int64] []T

下面是一个泛型的map：

type GenericMap[K comparable, V int | string | byte] map[K]V

下面是一个泛型的结构体：

type GenericStruct[T int | string] struct {Name stringId   T
}

如果有多个泛型，类型约束的时候用逗号分隔就行，如下面：

type GenericStruct[T int | string ,A int|string] struct {Name TId   A
}

下面是一个泛型接口和其实现：

type SayAble[T int | string] interface {Say() T
}type Person[T int | string] struct {msg T
}func (p Person[T]) Say() T {return p.msg
}func main() {var s SayAble[string]s = Person[string]{"hello world"}fmt.Println(s.Say())
}

注意，Person去实现接口的时候，可以不用泛型，比如上面这个例子，我下面这种写法也是没问题的，但是Person中msg字段类型的定义，必须为接口中类型约定中的，只能为int或者string：

type SayAble[T int | string] interface {Say() T
}type Person struct {msg int
}func (p Person) Say() int {return p.msg
}func main() {var s SayAble[int]s = Person{1}fmt.Println(s.Say())
}

类型集

最前面我们讲接口定义的时候就说到了类型集，下面我们看一个简单的类型集：

type SignedInt interface {int | string | float64 | bool | byte
}

然后配合泛型，配合接口融合起来去使用一下类型集：

func test[T SignedInt](a T) {fmt.Println(a)
}
func main() {test("1")test(1)test(1.0)test(true)test(1)
}console打印：
1
1
1
true
1

结语

go 的一大特点就是编译速度非常快，编译快是因为编译期做的优化少，泛型的加入会导致编译器的工作量增加，工作更加复杂，这必然会导致编译速度变慢，事实上当初 go1.18 刚推出泛型的时候确实导致编译更慢了，go 团队既想加入泛型又不想太拖累编译速度，开发者用的顺手，编译器就难受，反过来编译器轻松了（最轻松的当然是直接不要泛型），开发者就难受了，现如今的泛型就是这两者之间妥协后的产物。