接口interface

1.接口介绍

在Go语言中接口（interface）是一种类型，一种抽象的类型;
interface是一组method的集合，是duck-type programming的一种体现。接口做的事情就像是定义一个协议（规则），只要一台机器有洗衣服和甩干的功能，我就称它为洗衣机。不关心属性（数据），只关心行为（方法）;
为了保护你的Go语言职业生涯，请牢记接口（interface）是一种类型;

2.接口定义

2.1定义要求

2.2接口可以嵌入到其他接口里但必须得匿名

2.2.1接口里可以含一个接口时

type Phone interface {demo//不会报错
}
type demo interface {}

type Phone interface {aa demo//会编译报错
}
type demo interface {}

2.2.2接口里可以含多个接口时

// Sayer 接口
type Sayer interface {say()
}// Mover 接口
type Mover interface {move()
}// 接口嵌套
type animal interface {SayerMover
}type cat struct {name string
}func (c cat) say() {fmt.Println("喵喵喵")
}func (c cat) move() {fmt.Println("猫会动")
}func main() {var x animalx = cat{name: "花花"}x.move()x.say()
}

2.3接口没有数据字段

接口只有方法声明，没有实现，没有数据字段

2.4接口可以嵌入到结构体struct里

2.5空接口可以作为任何类型数据的容器

2.6接口命名习惯以 er 结尾

2.7实现接口的所有方法即可实现接口

实现接口条件:
接口被实现的条件一：接口的方法与实现接口的类型方法格式一致
接口被实现的条件二：接口中所有方法均被实现
任何类型的方法集中只要拥有该接口’对应的全部方法’签名就表示它 “实现” 了该接口，无须在该类型上显式声明实现了哪个接口，这称为Structural Typing；
所谓对应方法，是指有相同名称、参数列表 (不包括参数名) 以及返回值；
当然该类型还可以有其他方法

2.7.1没有嵌套其他接口时

// Sayer 接口
type Sayer interface {say()
}
type dog struct{}type cat struct{}
// dog实现了Sayer接口
func (d dog) say() {fmt.Println("汪汪汪")
}// cat实现了Sayer接口
func (c cat) say() {fmt.Println("喵喵喵")
}

2.7.1嵌套其他接口时正确实现

type Sayer interface {Listersay()
}
type Lister interface {lis()
}type cat struct{}// dog实现了Sayer接口
func (d cat) say() {fmt.Println("汪汪汪")
}// cat实现了Sayer接口
func (c cat) lis() {fmt.Println("喵喵喵")
}func main() {var x Sayer // 声明一个Sayer类型的变量xa := cat{}  // 实例化一个catx = a       // 会报错，原因缺少say方法x.say()     // 汪汪汪x.lis()
}

2.7.1嵌套其他接口时错误实现

type Sayer interface {Listersay()
}
type Lister interface {lis()
}
type dog struct{}type cat struct{}// dog实现了Sayer接口
func (d dog) say() {fmt.Println("汪汪汪")
}// cat实现了Sayer接口
func (c cat) lis() {fmt.Println("喵喵喵")
}func main() {var x Sayer // 声明一个Sayer类型的变量xa := cat{}  // 实例化一个catb := dog{}  // 实例化一个dogx = a       // 会报错，原因缺少say方法x = b       // 会报错，原因缺少lis方法x.say()     // 汪汪汪}

2.8接口是一个或多个方法签名的集合

2.9一个类型可以实现多个接口

2.9.1接口内方法不一样时

// 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 x Sayervar y Movervar a = dog{name: "旺财"}x = ay = ax.say()  //输出：旺财会叫汪汪汪y.move() //输出：旺财会动
}

2.9.2接口内方法一样时

// Sayer 接口
type Sayer interface {say()
}// Mover 接口
type Mover interface {say()
}type dog struct {name string
}// 实现Sayer接口
func (d dog) say() {fmt.Printf("%s会叫汪汪汪\n", d.name)
}func main() {var x Sayervar y Movervar a = dog{name: "旺财"}x = ay = ax.say() //输出：旺财会叫汪汪汪y.say()//输出：旺财会叫汪汪汪
}

2.10接口同样支持匿名方法

type Phone interface {func() string  //匿名时候需要加funcsay() string  //不匿名时候不用加func
}

2.11只有当接口存储的类型和对象都为nil时接口才等于nil

2.12接口类型的变量可使用其实例的方法

接口类型的变量可使用其实例的方法 ，但是不可以使用其实例的字段

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

2.13接口类型的变量不可以使用其实例的字段

// Sayer 接口
type Sayer interface {say()
}
type dog struct {a int
}// dog实现了Sayer接口
func (d dog) say() {fmt.Println("汪汪汪")
}func main() {var x Sayer b := dog{a :4,}x = b       x.say()    fmt.Println(x.a)   //会编译出错
}

2.14值接收者实现接口

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

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

2.15指针接收者实现接口

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

type Mover interface {move()
}type dog struct{}func (d *dog) move() {fmt.Println("狗会动")
}func main() {var x Movervar wangcai = dog{} // 旺财是dog类型x = wangcai         // 这一行会会议报错var fugui = &dog{}  // 富贵是*dog类型x = fugui           // x可以接收*dog类型x.move()
}

2.16多个类型实同一接口

// 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 Movervar a = dog{name: "旺财"}var b = car{brand: "保时捷"}x = ax.move() //输出：旺财会跑x = bx.move() //输出：保时捷速度70迈
}

2.17结构体中方法+结构体中所嵌套的结构体的方法来实现接口

接口的方法可以通过在类型中嵌入其他类型或者结构体来实现

// WashingMachine 洗衣机
type WashingMachine interface {wash()dry()
}// 甩干器
type dryer struct{}// 实现WashingMachine接口的dry()方法
func (d dryer) dry() {fmt.Println("甩一甩")
}// 海尔洗衣机
type haier struct {dryer //嵌入甩干器
}// 实现WashingMachine接口的wash()方法
func (h haier) wash() {fmt.Println("洗刷刷")
}
func main() {var x WashingMachinevar a haierx = ax.dry() //输出：甩一甩}

3.使用接口的原因

上面的代码中定义了猫和狗，然后它们都会叫，你会发现main函数中明显有重复的代码，如果我们后续再加上猪、青蛙等动物的话，我们的代码还会一直重复下去。那我们能不能把它们当成“能叫的动物”来处理呢？
像类似的例子在我们编程过程中会经常遇到：
比如一个网上商城可能使用支付宝、微信、银联等方式去在线支付，我们能不能把它们当成“支付方式”来处理呢？
比如三角形，四边形，圆形都能计算周长和面积，我们能不能把它们当成“图形”来处理呢？
比如销售、行政、程序员都能计算月薪，我们能不能把他们当成“员工”来处理呢？
Go语言中为了解决类似上面的问题，就设计了接口这个概念。接口区别于我们之前所有的具体类型，接口是一种抽象的类型。当你看到一个接口类型的值时，你不知道它是什么，唯一知道的是通过它的方法能做什么

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

4.接口的方法错误定义

package mainimport ("fmt"
)type Phone interface {call()
}
//会编译报错
func (i Phone) call() {fmt.Println("q23erg")
}
func main() {}

5.空接口

5.1空结构体占用16字节

type demo interface {
}func main() {var a demofmt.Println(unsafe.Sizeof(a)) //输出16var b interface{}fmt.Println(unsafe.Sizeof(b)) //输出16var c complex64fmt.Println(unsafe.Sizeof(c)) //输出8
}

5.2类型断言

5.1定义

5.2v,ok=x.(Y)应用

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

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

5.3type switch 语句介绍

5.4结合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！")}
}
func main() {var x interface{}x = "pprof.cn"justifyType(x) //输出：x is a string，value is pprof.cn
}