1. 接口

接口（interface）定义了一个对象的行为规范，只定义规范不实现，由具体的对象来实现规范的细节。

1.1. 接口

1.1.1. 接口类型

在Go语言中接口（interface）是一种类型，一种抽象的类型。

interface是一组method的集合，是duck-type programming的一种体现。接口做的事情就像是定义一个协议（规则），只要一台机器有洗衣服和甩干的功能，我就称它为洗衣机。不关心属性（数据），只关心行为（方法）。

为了保护你的Go语言职业生涯，请牢记接口（interface）是一种类型。

1.1.2. 为什么要使用接口

  1. type Cat struct{}
  3. func (c Cat) Say() string { return "喵喵喵" }
  5. type Dog struct{}
  7. func (d Dog) Say() string { return "汪汪汪" }
  9. func main() {
  10.     c := Cat{}
  11.     fmt.Println("猫:", c.Say())
  12.     d := Dog{}
  13.     fmt.Println("狗:", d.Say())
  14. }

上面的代码中定义了猫和狗，然后它们都会叫，你会发现main函数中明显有重复的代码，如果我们后续再加上猪、青蛙等动物的话，我们的代码还会一直重复下去。那我们能不能把它们当成“能叫的动物”来处理呢？

像类似的例子在我们编程过程中会经常遇到：

比如一个网上商城可能使用支付宝、微信、银联等方式去在线支付，我们能不能把它们当成“支付方式”来处理呢？

比如三角形，四边形，圆形都能计算周长和面积，我们能不能把它们当成“图形”来处理呢？

比如销售、行政、程序员都能计算月薪，我们能不能把他们当成“员工”来处理呢？

Go语言中为了解决类似上面的问题，就设计了接口这个概念。接口区别于我们之前所有的具体类型，接口是一种抽象的类型。当你看到一个接口类型的值时，你不知道它是什么，唯一知道的是通过它的方法能做什么。

1.1.3. 接口的定义

Go语言提倡面向接口编程。

  1.     接口是一个或多个方法签名的集合。
  2.     任何类型的方法集中只要拥有该接口'对应的全部方法'签名。
  3.     就表示它 "实现" 了该接口，无须在该类型上显式声明实现了哪个接口。
  4.     这称为Structural Typing。
  5.     所谓对应方法，是指有相同名称、参数列表 (不包括参数名) 以及返回值。
  6.     当然，该类型还可以有其他方法。
  8.     接口只有方法声明，没有实现，没有数据字段。
  9.     接口可以匿名嵌入其他接口，或嵌入到结构中。
  10.     对象赋值给接口时，会发生拷贝，而接口内部存储的是指向这个复制品的指针，既无法修改复制品的状态，也无法获取指针。
  11.     只有当接口存储的类型和对象都为nil时，接口才等于nil。
  12.     接口调用不会做receiver的自动转换。
  13.     接口同样支持匿名字段方法。
  14.     接口也可实现类似OOP中的多态。
  15.     空接口可以作为任何类型数据的容器。
  16.     一个类型可实现多个接口。
  17.     接口命名习惯以 er 结尾。

每个接口由数个方法组成，接口的定义格式如下：

  1.     type 接口类型名 interface{
  2.         方法名1( 参数列表1 ) 返回值列表1
  3.         方法名2( 参数列表2 ) 返回值列表2
  4.         …
  5.     }

其中：

  1.     1.接口名：使用type将接口定义为自定义的类型名。Go语言的接口在命名时，一般会在单词后面添加er，如有写操作的接口叫Writer，有字符串功能的接口叫Stringer等。接口名最好要能突出该接口的类型含义。
  2.     2.方法名：当方法名首字母是大写且这个接口类型名首字母也是大写时，这个方法可以被接口所在的包（package）之外的代码访问。
  3.     3.参数列表、返回值列表：参数列表和返回值列表中的参数变量名可以省略。

举个例子：

  1. type writer interface{
  2.     Write([]byte) error
  3. }

当你看到这个接口类型的值时，你不知道它是什么，唯一知道的就是可以通过它的Write方法来做一些事情。

1.1.4. 实现接口的条件

一个对象只要全部实现了接口中的方法，那么就实现了这个接口。换句话说，接口就是一个需要实现的方法列表。

我们来定义一个Sayer接口：

  1. // Sayer 接口
  2. type Sayer interface {
  3.     say()
  4. }

定义dog和cat两个结构体：

  1. type dog struct {}
  3. type cat struct {}

因为Sayer接口里只有一个say方法，所以我们只需要给dog和cat 分别实现say方法就可以实现Sayer接口了。

  1. // dog实现了Sayer接口
  2. func (d dog) say() {
  3.     fmt.Println("汪汪汪")
  4. }
  6. // cat实现了Sayer接口
  7. func (c cat) say() {
  8.     fmt.Println("喵喵喵")
  9. }

接口的实现就是这么简单，只要实现了接口中的所有方法，就实现了这个接口。

1.1.5. 接口类型变量

那实现了接口有什么用呢？

接口类型变量能够存储所有实现了该接口的实例。 例如上面的示例中，Sayer类型的变量能够存储dog和cat类型的变量。

  1. func main() {
  2.     var x Sayer // 声明一个Sayer类型的变量x
  3.     a := cat{}  // 实例化一个cat
  4.     b := dog{}  // 实例化一个dog
  5.     x = a       // 可以把cat实例直接赋值给x
  6.     x.say()     // 喵喵喵
  7.     x = b       // 可以把dog实例直接赋值给x
  8.     x.say()     // 汪汪汪
  9. }

1.1.6. 值接收者和指针接收者实现接口的区别

使用值接收者实现接口和使用指针接收者实现接口有什么区别呢？接下来我们通过一个例子看一下其中的区别。

我们有一个Mover接口和一个dog结构体。

  1. type Mover interface {
  2.     move()
  3. }
  5. type dog struct {}

1.1.7. 值接收者实现接口

  1. func (d dog) move() {
  2.     fmt.Println("狗会动")
  3. }

此时实现接口的是dog类型：

  1. func main() {
  2.     var x Mover
  3.     var wangcai = dog{} // 旺财是dog类型
  4.     x = wangcai         // x可以接收dog类型
  5.     var fugui = &dog{}  // 富贵是*dog类型
  6.     x = fugui           // x可以接收*dog类型
  7.     x.move()
  8. }

从上面的代码中我们可以发现，使用值接收者实现接口之后，不管是dog结构体还是结构体指针*dog类型的变量都可以赋值给该接口变量。因为Go语言中有对指针类型变量求值的语法糖，dog指针fugui内部会自动求值*fugui。

1.1.8. 指针接收者实现接口

同样的代码我们再来测试一下使用指针接收者有什么区别：

  1. func (d *dog) move() {
  2.     fmt.Println("狗会动")
  3. }
  4. func main() {
  5.     var x Mover
  6.     var wangcai = dog{} // 旺财是dog类型
  7.     x = wangcai         // x不可以接收dog类型
  8.     var fugui = &dog{}  // 富贵是*dog类型
  9.     x = fugui           // x可以接收*dog类型
  10. }

此时实现Mover接口的是*dog类型，所以不能给x传入dog类型的wangcai，此时x只能存储*dog类型的值。

1.1.9. 下面的代码是一个比较好的面试题

请问下面的代码是否能通过编译？

  1. type People interface {
  2.     Speak(string) string
  3. }
  5. type Student struct{}
  7. func (stu *Stduent) Speak(think string) (talk string) {
  8.     if think == "sb" {
  9.         talk = "你是个大帅比"
  10.     } else {
  11.         talk = "您好"
  12.     }
  13.     return
  14. }
  16. func main() {
  17.     var peo People = Student{}
  18.     think := "bitch"
  19.     fmt.Println(peo.Speak(think))
  20. }

1.2. 类型与接口的关系

1.2.1. 一个类型实现多个接口

一个类型可以同时实现多个接口，而接口间彼此独立，不知道对方的实现。 例如，狗可以叫，也可以动。我们就分别定义Sayer接口和Mover接口，如下： Mover接口。

  1. // Sayer 接口
  2. type Sayer interface {
  3.     say()
  4. }
  6. // Mover 接口
  7. type Mover interface {
  8.     move()
  9. }

dog既可以实现Sayer接口，也可以实现Mover接口。

  1. type dog struct {
  2.     name string
  3. }
  5. // 实现Sayer接口
  6. func (d dog) say() {
  7.     fmt.Printf("%s会叫汪汪汪\n", d.name)
  8. }
  10. // 实现Mover接口
  11. func (d dog) move() {
  12.     fmt.Printf("%s会动\n", d.name)
  13. }
  15. func main() {
  16.     var x Sayer
  17.     var y Mover
  19.     var a = dog{name: "旺财"}
  20.     x = a
  21.     y = a
  22.     x.say()
  23.     y.move()
  24. }

1.2.2. 多个类型实现同一接口

Go语言中不同的类型还可以实现同一接口 首先我们定义一个Mover接口，它要求必须由一个move方法。

  1. // Mover 接口
  2. type Mover interface {
  3.     move()
  4. }

例如狗可以动，汽车也可以动，可以使用如下代码实现这个关系：

  1. type dog struct {
  2.     name string
  3. }
  5. type car struct {
  6.     brand string
  7. }
  9. // dog类型实现Mover接口
  10. func (d dog) move() {
  11.     fmt.Printf("%s会跑\n", d.name)
  12. }
  14. // car类型实现Mover接口
  15. func (c car) move() {
  16.     fmt.Printf("%s速度70迈\n", c.brand)
  17. }

这个时候我们在代码中就可以把狗和汽车当成一个会动的物体来处理了，不再需要关注它们具体是什么，只需要调用它们的move方法就可以了。

  1. func main() {
  2.     var x Mover
  3.     var a = dog{name: "旺财"}
  4.     var b = car{brand: "保时捷"}
  5.     x = a
  6.     x.move()
  7.     x = b
  8.     x.move()
  9. }

上面的代码执行结果如下：

  1.     旺财会跑
  2.     保时捷速度70迈

并且一个接口的方法，不一定需要由一个类型完全实现，接口的方法可以通过在类型中嵌入其他类型或者结构体来实现。

  1. // WashingMachine 洗衣机
  2. type WashingMachine interface {
  3.     wash()
  4.     dry()
  5. }
  7. // 甩干器
  8. type dryer struct{}
  10. // 实现WashingMachine接口的dry()方法
  11. func (d dryer) dry() {
  12.     fmt.Println("甩一甩")
  13. }
  15. // 海尔洗衣机
  16. type haier struct {
  17.     dryer //嵌入甩干器
  18. }
  20. // 实现WashingMachine接口的wash()方法
  21. func (h haier) wash() {
  22.     fmt.Println("洗刷刷")
  23. }

1.2.3. 接口嵌套

接口与接口间可以通过嵌套创造出新的接口。

  1. // Sayer 接口
  2. type Sayer interface {
  3.     say()
  4. }
  6. // Mover 接口
  7. type Mover interface {
  8.     move()
  9. }
  11. // 接口嵌套
  12. type animal interface {
  13.     Sayer
  14.     Mover
  15. }

嵌套得到的接口的使用与普通接口一样，这里我们让cat实现animal接口：

  1. type cat struct {
  2.     name string
  3. }
  5. func (c cat) say() {
  6.     fmt.Println("喵喵喵")
  7. }
  9. func (c cat) move() {
  10.     fmt.Println("猫会动")
  11. }
  13. func main() {
  14.     var x animal
  15.     x = cat{name: "花花"}
  16.     x.move()
  17.     x.say()
  18. }

1.3. 空接口

1.3.1. 空接口的定义

空接口是指没有定义任何方法的接口。因此任何类型都实现了空接口。

空接口类型的变量可以存储任意类型的变量。

  1. func main() {
  2.     // 定义一个空接口x
  3.     var x interface{}
  4.     s := "pprof.cn"
  5.     x = s
  6.     fmt.Printf("type:%T value:%v\n", x, x)
  7.     i := 100
  8.     x = i
  9.     fmt.Printf("type:%T value:%v\n", x, x)
  10.     b := true
  11.     x = b
  12.     fmt.Printf("type:%T value:%v\n", x, x)
  13. }

1.3.2. 空接口的应用

空接口作为函数的参数

使用空接口实现可以接收任意类型的函数参数。

  1. // 空接口作为函数参数
  2. func show(a interface{}) {
  3.     fmt.Printf("type:%T value:%v\n", a, a)
  4. }

空接口作为map的值

使用空接口实现可以保存任意值的字典。

  1. // 空接口作为map值
  2.     var studentInfo = make(map[string]interface{})
  3.     studentInfo["name"] = "李白"
  4.     studentInfo["age"] = 18
  5.     studentInfo["married"] = false
  6.     fmt.Println(studentInfo)

1.3.3. 类型断言

空接口可以存储任意类型的值，那我们如何获取其存储的具体数据呢？

接口值

一个接口的值（简称接口值）是由一个具体类型和具体类型的值两部分组成的。这两部分分别称为接口的动态类型和动态值。

我们来看一个具体的例子：

  1. var w io.Writer
  2. w = os.Stdout
  3. w = new(bytes.Buffer)
  4. w = nil

请看下图分解：

分解

想要判断空接口中的值这个时候就可以使用类型断言，其语法格式：

  1.     x.(T)

其中：

  1.     x：表示类型为interface{}的变量
  2.     T：表示断言x可能是的类型。

该语法返回两个参数，第一个参数是x转化为T类型后的变量，第二个值是一个布尔值，若为true则表示断言成功，为false则表示断言失败。

举个例子：

  1. func main() {
  2.     var x interface{}
  3.     x = "pprof.cn"
  4.     v, ok := x.(string)
  5.     if ok {
  6.         fmt.Println(v)
  7.     } else {
  8.         fmt.Println("类型断言失败")
  9.     }
  10. }

上面的示例中如果要断言多次就需要写多个if判断，这个时候我们可以使用switch语句来实现：

  1. func justifyType(x interface{}) {
  2.     switch v := x.(type) {
  3.     case string:
  4.         fmt.Printf("x is a string，value is %v\n", v)
  5.     case int:
  6.         fmt.Printf("x is a int is %v\n", v)
  7.     case bool:
  8.         fmt.Printf("x is a bool is %v\n", v)
  9.     default:
  10.         fmt.Println("unsupport type！")
  11.     }
  12. }

因为空接口可以存储任意类型值的特点，所以空接口在Go语言中的使用十分广泛。

关于接口需要注意的是，只有当有两个或两个以上的具体类型必须以相同的方式进行处理时才需要定义接口。不要为了接口而写接口，那样只会增加不必要的抽象，导致不必要的运行时损耗。