Go语言之路------------接口
前言
- 我是一名多年Java开发人员，因为工作需要现在要学习go语言，Go语言之路是一个系列，记录着我从0开始接触Go，到后面能正常完成工作上的业务开发的过程，如果你也是个小白或者转Go语言的，希望我这篇文章对你有所帮助。
- 有关go其他基础的内容的文章大家可以查看我的主页，接下来主要就是把这个系列更完，更完之后我会在每篇文章中挂上连接，方便大家跳转和复习。
接口定义
什么是接口？如果有学过Java的，你就把它和Java的接口类比就行，相似度很高，没有学过的我们就看看官方定义
1.18之前
定义：一组方法的集合
实现：当一个类型的方法集是一个接口的方法集的超集时，且该类型的值可以由该接口类型的变量存储，那么称该类型实现了该接口
1.18之后
定义：一组类型的集合
实现：当一个类型位于一个接口的类型集内，且该类型的值可以由该接口类型的变量存储，那么称该类型实现了该接口
为啥会在这个版本之间有差别，因为go的1.18版本是个很大的分水岭，这个版本引入了很多新东西，影响接口定义的就是泛型，大家可以理解为jdk8版本这一划时代的影响。
官方文档的定义和实现苦涩难懂，但是官方的东西大家懂的都懂，鸟用没有全是一些很官方的话，你可以不用去理解上面这一大段东西，你只需要知道一个类型实现接口A的所有方法，那么就称这个类型实现了这个接口，跟Java差不多
实操，接口的定义和实现
说了那么多来点实在的，go中结构的定义和Java一样，还是用interface，下面我们看下一个简单的接口定义：
go
type Animal interface {
Shut() string
}那么怎么去实现接口：
go
type Dog struct {
}
func (receiver Dog) Shut() string {
return "汪汪汪"
}我们创建一个Dog的结构体，它有一个方法Shut，刚好Animal 接口也只有一个方法Shut，这样我们就称Dog实现了Animal 接口，就这么简单。
验证下：
go
func main() {
animals := []Animal{Dog{}}
for _, a := range animals {
fmt.Println(a.Shut())
}
}
console：
汪汪汪我们创建一个Animal类型的切片，里面放入Dog结构体，因为Dog实现了Animal接口，所以他们类型一样，可以正常编码。
接口的继承
任何自定义类型都可以拥有方法，那么根据实现的定义，任何自定义类型都可以实现接口，那么接口也可以实现接口，这就相当于Java中的继承，用法一个样，看我举例说明：
go
type Animal interface {
Shut() string
}
type Dog interface {
AA() string
Animal
}我们上面定义了Animal 的接口，表示动物这一种类，但是我现在还想细分一下，动物很多种，我这里再定义一个狗的接口，实现了Animal 的接口，只需要在Dog的接口字段中声明Animal ，这就实现了继承
我再创建一个结构体二哈，表示狗的一个种类
go
type ErHa struct {
}
func (receiver ErHa) Shut() string {
return "汪汪汪"
}
func (receiver ErHa) AA() string {
return "二哈"
}注意，这里的EeHa一定要实现Dog 和Animal 的所有方法，不然会报错。
然后验证一下：
go
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看，其实它就是一个空接口
go
type any = interface{}泛型
一句话，跟Java的定义一样，只是写法不一样
因为go在1.18后才支持泛型，所有使用的时候要指定go的版本，在go.mod文件中添加如下一行：
go
go 1.18然后我们看看代码示例：
go
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，竖线分隔就行。
下面是一个泛型的切片：
go
type GenericSlice[T int | int32 | int64] []T下面是一个泛型的map：
go
type GenericMap[K comparable, V int | string | byte] map[K]V下面是一个泛型的结构体：
go
type GenericStruct[T int | string] struct {
Name string
Id T
}如果有多个泛型，类型约束的时候用逗号分隔就行，如下面：
go
type GenericStruct[T int | string ,A int|string] struct {
Name T
Id A
}下面是一个泛型接口和其实现：
go
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：
go
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())
}类型集
最前面我们讲接口定义的时候就说到了类型集，下面我们看一个简单的类型集：
go
type SignedInt interface {
int | string | float64 | bool | byte
}然后配合泛型，配合接口融合起来去使用一下类型集：
go
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 团队既想加入泛型又不想太拖累编译速度，开发者用的顺手，编译器就难受，反过来编译器轻松了（最轻松的当然是直接不要泛型），开发者就难受了，现如今的泛型就是这两者之间妥协后的产物。