一、接口

• 接口（interface）定义了一个对象的行为规范，只是定义规范，由具体的对象来实现规范的细节
• 在Go语言中，接口（interface）是一种类型，一种抽象的类型
• interface 是一组 方法(method) 的集合，是 duck-type programming 的一种体现。接口做的事情就像是定义一个协议（规则），只要一台机器有洗衣服和甩干的功能，我就称它为洗衣机。不关心属性（数据），只关心行为（方法）
• Go语言提倡面向接口编程，就像python中提倡面向对象编程一样（但关于接口需要注意的是，只有当有两个或两个以上的具体类型必须以相同的方式进行处理时才需要定义接口。不要为了接口而写接口，那样只会增加不必要的抽象，导致不必要的运行时损耗）

二、为什么要使用接口

• 简单来说是为了解决程序中重复定义相同功能的代码，使得我们能够更便捷的使用一种功能
• 如下面的情景

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())
}

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

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

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

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

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

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

三、接口的定义

• 每个接口由数个方法组成，接口的定义格式如下
• 接口名一般在名字后面添加 er 后缀

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

其中：

- 接口名：使用type将接口定义为自定义的类型名。Go语言的接口在命名时，一般会在单词后面添加 er ，如有写操作的接口叫Writer，有字符串功能的接口叫Stringer等。接口名最好要能突出该接口的类型含义***************************************

- 方法名：当方法名首字母是大写且这个接口类型名首字母也是大写时，这个方法可以被接口所在的包（package）之外的代码访问

- 参数列表、返回值列表：参数列表和返回值列表中的参数变量名可以省略

简单示例：

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

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

四、实现接口的条件

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

  我们来定义一个 Sayer 接口

• 实现接口的示例

package main

import (
	"fmt"
)

type Sayer interface {
	say(name string)
}

type dog struct{}

type cat struct{}

// 因为Sayer接口里只有一个say方法，所以我们只需要给dog和cat分别实现say方法就可以实现Sayer接口了，相当于实现了两次Sayer接口
// 接口的实现就是这么简单，只要实现了接口中的所有方法，就实现了这个接口
func (d dog) say(name string) {
	fmt.Printf("小狗：%s 叫了一声", name)
}

func (c cat) say(name string) {
	fmt.Printf("小猫：%s 叫了一声", name)
}

五、接口类型的变量

• 接口类型变量能够 存储 所有实现了该接口的实例（即：可以将该实例赋值给接口类型变量）
  • 但是这里有个小小的区别：
    • 该实例为值
    • 该实例为指针类型

1. 值接收者实现接口

• 使用值接收者实现接口之后，不管是结构体，还是结构体指针类型的变量都可以赋值给该接口变量

// 如下示例
package main

import (
	"fmt"
)

type Sayer interface {
	say(name string)
}

type dog struct{}

type cat struct{}

func (d dog) say(name string) {
	fmt.Printf("小狗：%s 叫了一声", name)
}

func (c cat) say(name string) {
	fmt.Printf("小猫：%s 叫了一声\n", name)
}

func main() {
	var s Sayer  // 声明一个Sayer类型的变量s
	x := cat{}  // 实例化一个cat，此时的x为值
	s = x  // 可以把cat实例直接赋值给 s
	s.say("花花1号")
    
    y := &cat{}  // 实例化一个cat，此时的y为指针类型
	s = y  // **************也可以把指针类型的cat实例直接赋值给 s******************
	s.say("花花2号")
    
    z := &cat{}  // 实例化一个dog，此时的z为指针类型
	s = z  // **************也可以把指针类型的dog实例直接赋值给 s******************
	s.say("旺财")
}

/*
分析：
使用值接收者实现接口之后，不管是cat结构体还是结构体指针*cat类型的变量都可以赋值给该接口变量。因为Go语言中有对指针类型变量求值的语法糖，cat指针y内部会自动求值 *y
*/

2. 指针类型接收者实现接口

• 使用指针类型接收者实现接口之后，只能用结构体指针类型的变量赋值给该接口变量

// 如下示例
package main

import (
	"fmt"
)

type Sayer interface {
	say(name string)
}

type dog struct{}

type cat struct{}

func (c *cat) say(name string) {
	fmt.Printf("小猫：%s 叫了一声\n", name)
}

func main() {
	var s Sayer  // 声明一个Sayer类型的变量s
	x := cat{}  // 实例化一个cat，此时的x为值
	s = x  // 注意：这里会报错，s不可以接收cat类型 *********************
	s.say("旺财")
    
    y := &cat{}  // 实例化一个cat，此时的y为指针类型
	s = y  // **************可以把指针类型的cat实例直接赋值给 s ******************
	s.say("花花")
}

3. 接口进阶示例

• 可以将上面的代码再进行简化

package main

import (
	"fmt"
)

type Sayer interface {
	say(string, string)
}

type animal struct{}

func (ani *animal) say(dongwu, name string) {
	fmt.Printf("%s:%s 叫了一声\n", dongwu, name)
}

func main() {
	//var s Sayer
	//x := animal{}
	//s = x

	var s Sayer = &animal{}  // 将上面3行，简写为这一行

	s.say("小猫", "花花")
	s.say("小狗", "旺财")
}

六、同一个类型实现多个接口

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

package main

import (
	"fmt"
)

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

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

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 s Sayer
	var m Mover

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

七、多个类型实现同一个接口

package main

import (
	"fmt"
)

// 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)
}

func main() {
	var x Mover
	var a = dog{name: "旺财"}
	var b = car{brand: "保时捷"}
	x = a
	x.move()  // 旺财会跑
	x = b
	x.move()  // 保时捷速度70迈
}

八、类型中的嵌套去实现接口

• 结构体1中嵌套了结构体2，结构体2去实现接口
• 利用了继承的思想

package main

import (
	"fmt"
)

// WashingMachine 洗衣机
type WashingMachine interface {
	wash()
	dry()
}

// 甩干器
type dryer struct{}

// 实现WashingMachine接口的dry()方法
func (d dryer) dry() {
	fmt.Println("甩一甩")
}

// 海尔洗衣机
type haier struct {
	dryer //嵌入甩干器，相当于haier继承了dryer的属性
}

// 实现WashingMachine接口的wash()方法
func (h haier) wash() {
	fmt.Println("洗刷刷")
}

// 错误写法*********
func main1() {
    h := haier{}
	var w1 WashingMachine  
	w1 = h.dryer  // 这里就会语法错误，不用往下写了
}

// 正确写法*********
func main() {
	var w WashingMachine = haier{}
	w.wash()
	w.dry()
}

九、接口嵌套

• 接口嵌套就是：接口中含有其他接口
• 嵌套得到的接口的使用与普通接口一样

package main

import (
	"fmt"
)

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

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

// 接口嵌套，相当于 animal 接口继承了 Sayer 和 Mover 的属性
type animal interface {
	Sayer
	Mover
}

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()
}

十、空接口

• 空接口是指没有定义任何方法的接口。因此任何类型都实现了空接口
• 空接口类型的变量可以存储任意类型的变量
• 因为空接口可以存储任意类型值的特点，所以空接口在Go语言中的使用十分广泛

1. 空接口的定义

• 只有一种定义方式：var 接口名 interface{}

func main() {
	// 定义一个空接口x
	var x interface{}
	s := "Hello 沙河"
	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)
}

/*
type:string value:Hello 沙河
type:int value:100  
type:bool value:true
*/

2. 空接口作为函数的参数

• 原理是使用空接口实现可以存储任意类型的值

package main

import (
	"fmt"
)

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

func main() {

	show(11)  // 接收int类型
	show("11")  // 接收string类型

	a := []int{}
	show(a)  // 接收切片类型

	b := map[string]int{}
	show(b)  // 接收map类型

	type s struct{}
	c := s{}
	show(c)  // 接收结构体类型
}

/*
type:int value:11
type:string value:11           
type:[]int value:[]            
type:map[string]int value:map[]
type:main.s value:{}
*/

3. 空接口作为map的值

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

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

十一、类型断言

• 既然空接口可以存储任意类型的值，那么如何才能知道接口中的值是什么类型呢，这时候就要用到类型断言
• 一个接口的值（简称接口值）是由一个具体类型和具体类型的值两部分组成的，这两部分分别称为接口的动态类型和动态值
• 想要判断空接口中的值，这个时候就可以使用类型断言

类型断言的语法格式为：
x.(T)

其中：

- x：表示类型为interface{}的变量

- T：表示断言x可能是的类型

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


// 简单示例：

func main() {
	var x interface{}
	x = "Hello 沙河"
	//x = 22
	v, ok := x.(string)
	if ok {
		fmt.Println(ok)
		fmt.Println(v)
	} else {
		fmt.Println(ok)
		fmt.Println(v)
		fmt.Println("类型断言失败")
	}
}

/*
true
Hello 沙河

若将 x = 22 的注释打开，则打印结果为：
false

类型断言失败
*/

1. 进阶示例

package main

import (
	"fmt"
)

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)
	case []int:
		fmt.Printf("x is a []int is %v\n", v)
	case map[string]int:
		fmt.Printf("x is a map[string]int is %v\n", v)
	default:
		fmt.Println("unsupport type！")
	}
}

func main() {
	justifyType(11)
	justifyType("11")
	justifyType(false)
	justifyType([]int{})
	justifyType(map[string]int{})
	justifyType(struct {
	}{})
}

/*
x is a int is 11
x is a string，value is 11    
x is a bool is false          
x is a []int is []            
x is a map[string]int is map[]
unsupport type！
*/