Go语言基础 -- 接口(interface)

1. 接口是什么

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

2. 接口类型

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

interface是一组method的集合，是duck-type programming的一种体现。

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

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

3. 为什么要使用接口

type Cat struct{}

func (c Cat) Say() string { return "喵喵喵" }

type Dog struct{}

func (d Dog) Say() string { return "汪汪汪" }

func main() {
    c := Cat{}
    fmt.Println("猫:", c.Say())
    d := Dog{}
    fmt.Println("狗:", d.Say())
}

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

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

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

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

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

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

4. 接口的定义规则

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

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

5. 接口定义

1. 格式

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

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

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

2. 示例

type writer interface{
    Write([]byte) error
}

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

6. 实现接口的条件

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

我们来定义一个Sayer接口：

// Sayer 接口
type Sayer interface {
    say()
}

定义dog和cat两个结构体：

type dog struct {}

type cat struct {}

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

// dog实现了Sayer接口
func (d dog) say() {
    fmt.Println("汪汪汪")
}

// cat实现了Sayer接口
func (c cat) say() {
    fmt.Println("喵喵喵")
}

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

7. 接口类型变量

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

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

package main

import "fmt"

type Sayer interface {
	say()
}
type dog struct{}

// dog实现了Sayer接口
func (d dog) say() {
	fmt.Println("汪汪汪")
}

type cat struct{}

// cat实现了Sayer接口
func (c cat) say() {
	fmt.Println("喵喵喵")
}
func main() {
	var x Sayer // 声明一个Sayer类型的变量x
	a := cat{}  // 实例化一个cat
	b := dog{}  // 实例化一个dog
	x = a       // 可以把cat实例直接赋值给x
	x.say()  
	x = b       // 可以把dog实例直接赋值给x
	x.say()   
}

// 运行结果
喵喵喵
汪汪汪

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

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

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

type Mover interface {
    move()
}

type dog struct {}

8.1 值接收者实现接口

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

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

func main() {
    var x Mover
    var wangcai = dog{} // 旺财是dog类型
    x = wangcai         // x可以接收dog类型
    var fugui = &dog{}  // 富贵是*dog类型
    x = fugui           // x可以接收*dog类型
    x.move()
}

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

8.2 指针接收者实现接口

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

func (d *dog) move() {
    fmt.Println("狗会动")
}
func main() {
    var x Mover
    var wangcai = dog{} // 旺财是dog类型
    x = wangcai         // x不可以接收dog类型
    var fugui = &dog{}  // 富贵是*dog类型
    x = fugui           // x可以接收*dog类型
}

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

9. 类型与接口的关系

9.1 一个实现多个接口

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

// Sayer 接口
type Sayer interface {
    say()
}

// Mover 接口
type Mover interface {
    move()
}

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

type dog struct {
    name string
}

// 实现Sayer接口
func (d dog) say() {
    fmt.Printf("%s会叫汪汪汪\n", d.name)
}

// 实现Mover接口
func (d dog) move() {
    fmt.Printf("%s会动\n", d.name)
}

func main() {
    var x Sayer
    var y Mover

    var a = dog{name: "旺财"}
    x = a
    y = a
    x.say()
    y.move()
}

9.2 多个类型实现同一接口

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

// Mover 接口
type Mover interface {
    move()
}

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

type dog struct {
    name string
}

type car struct {
    brand string
}

// dog类型实现Mover接口
func (d dog) move() {
    fmt.Printf("%s会跑\n", d.name)
}

// car类型实现Mover接口
func (c car) move() {
    fmt.Printf("%s速度70迈\n", c.brand)
}

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

func main() {
    var x Mover
    var a = dog{name: "旺财"}
    var b = car{brand: "保时捷"}
    x = a
    x.move()
    x = b
    x.move()
}

// 运行结果
旺财会跑
保时捷速度70迈

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

package main

import "fmt"

// 洗衣机的功能接口
type washingmachine interface {
	wash()
	dry()
}

// 甩干机
type dryer struct {
}

func (d dryer) dry() {
	fmt.Println("甩一甩")
}

// haier品牌的洗衣机
type haier struct {
	dryer
}

func (h haier) wash() {
	fmt.Println("洗一洗")
}

func main() {
	// 1. dryer实现了dry方法
	// 2. haier 这个结构体通过内部嵌入 dryer,同时实现了wash 方法,所以实现了 washingmachine 接口
	h1 := haier{}
	var w washingmachine

	// 3. 所以 可以将 haier 结构体,赋值给 washingmachine 接口的实例,同时可以调用两个方法
	w = h1
	w.wash()
	w.dry()

	// dryer 只实现了dry 方法,而没有实现另一个wash 方法,所以无法赋值给 washingmachine的实例
	d1 := dryer{}
	w = d1
	w.wash()
}

9.3 一个类型实现嵌套接口

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

// Sayer 接口
type Sayer interface {
    say()
}

// Mover 接口
type Mover interface {
    move()
}

// 接口嵌套
type animal interface {
    Sayer
    Mover
}

此时如果向实现animal接口,就必须实现这三个接口的所有方法：

type cat struct {
    name string
}

func (c cat) say() {
    fmt.Println("喵喵喵")
}

func (c cat) move() {
    fmt.Println("猫会动")
}

func main() {
    var x animal
    x = cat{name: "花花"}
    x.move()
    x.say()
}

9.4 一个自定义类型实现了接口

package main

import (
	"fmt"
)

type namer interface {
	say()
}

type Aname []int

func (a Aname) say() {
	fmt.Println("自定义Aname实现了namer接口")
}

func main() {
	var a Aname = Aname{1, 2, 3, 4}
	a.say()
}

// 运行结果
自定义Aname实现了namer接口

10. 空接口

10.1 空接口的定义

空接口i没有任何方法,所以所有类型都实现了空接口,即可以把任何变量赋值给空接口类型

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

func main() {
    // 定义一个空接口x
    var x interface{}
    s := "pprof.cn"
    x = s
    fmt.Printf("type:%T value:%v\n", x, x)
    i := 100
    x = i
    fmt.Printf("type:%T value:%v\n", x, x)
    b := true
    x = b
    fmt.Printf("type:%T value:%v\n", x, x)
}

10.2 空接口的应用

10.2.1 空接口作为函数的参数

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

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

10.2.2 空接口作为map的值

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

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

11. 接口的最佳实践

用系统函数,对slice切片进行排序:sort.Sort(data interface)
源码(需要实现接口定义的三个方法才可以使用Sort()方法,进行排序)

type Interface interface {
	Len() int
	Less(i, j int) bool
	Swap(i, j int)
}

代码实现

package main

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

type Hero struct {
	name string
	age  int
}

type HerSlice []Hero // 自定义 HerSlice 类型

func (h HerSlice) Len() int { return len(h) } // 返回结构体切片的长度

func (h HerSlice) Less(i, j int) bool { return h[i].age > h[j].age } // 按照指定规则进行排序

func (h HerSlice) Swap(i, j int) { h[i], h[j] = h[j], h[i] } // 交换两个变量的值

func main() {
	// 生成 结构体 切片
	var heroes HerSlice
	for i := 0; i < 10; i++ {
		hero := Hero{
			name: fmt.Sprintf("英雄-%d", rand.Intn(100)),
			age:  rand.Intn(100),
		}
		heroes = append(heroes, hero)
	}

	fmt.Println("排序前", heroes)
    
	// 调用 sort.Sort 进行排序
	sort.Sort(heroes)
	fmt.Println("排序后", heroes)

}

// 运行结果
排序前 [{英雄-81 87} {英雄-47 59} {英雄-81 18} {英雄-25 40} {英雄-56 0} {英雄-94 11} {英雄-62 89} {英雄-28 74} {英雄-11 45} {英雄-37 6}]
排序后 [{英雄-62 89} {英雄-81 87} {英雄-28 74} {英雄-47 59} {英雄-11 45} {英雄-25 40} {英雄-81 18} {英雄-94 11} {英雄-37 6} {英雄-56 0}]

sort.Strings 底层代码

// string 切片
type StringSlice []string

// 实现了Interface 接口,
func (x StringSlice) Len() int           { return len(x) }
func (x StringSlice) Less(i, j int) bool { return x[i] < x[j] }
func (x StringSlice) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

// 实现了Interface接口,才能调用Sort函数
func Strings(x []string) { Sort(StringSlice(x)) }

12. 实现接口 VS 继承

1. 当A结构体继承了B结构体,那么 A 结构体 就集成了B结构体的字段和方法,并且可以直接使用
2. 当A结构体需要扩展功能,同时不希望破坏继承关系,则可以通过实现某个接口实现
   
3. 接口和继承解决的问题不同
   继承的价值主要在于,解决代码的复用性和可维护性
   接口的价值主要在于,设计好各种难规范(方法),让其他自定义类型去实现方法
4. 接口比继承更灵活,继承是满足is a 的关系,接口只需满足like a 的关系即可
5. 接口在一定程度上实现了代码解耦

13. 类型断言

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

1. 接口值

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

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

var w io.Writer
w = os.Stdout
w = new(bytes.Buffer)
w = nil

请看下图分解：

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

x.(T)

其中：

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

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

举个例子：

package main

import "fmt"

func main() {
	var x interface{}
	x = "pprof.cn"
	v, ok := x.(int)
	if ok {
		fmt.Println(v)
	} else {
		fmt.Println("类型断言失败")
	}
}

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

func justifyType(x interface{}) {
    switch v := x.(type) {
    case string:
        fmt.Printf("x is a string，value is %v\n", v)
    case int:
        fmt.Printf("x is a int is %v\n", v)
    case bool:
        fmt.Printf("x is a bool is %v\n", v)
    default:
        fmt.Println("unsupport type！")
    }
}

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

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

14. 面试题

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

package main

import "fmt"

type People interface {
	Speak(string) string
}

type Student struct{}

func (stu *Student) Speak(think string) (talk string) {
	if think == "sb" {
		talk = "你是个大帅比"
	} else {
		talk = "您好"
	}
	return
}

func main() {
	var peo People = &Student{}
	think := "bitch"
	fmt.Println(peo.Speak(think))
}