1、接口的引入

以日常生活中打招呼为例，定义接口规范，各国人为打招呼为具体的实现

package main
import "fmt"//接口的定义：定义规则、定义规范，定义某种能力：
type SayHello interface{//声明没有实现的方法：sayHello()
}=========================================分割线
//接口的实现：定义一个结构体：
//中国人：
type Chinese struct{
}
//实现接口的方法---》具体的实现：
func (person Chinese) sayHello(){fmt.Println("你好")
}=========================================分割线//接口的实现：定义一个结构体：
//美国人：
type American struct{
}
//实现接口的方法---》具体的实现：
func (person American) sayHello(){fmt.Println("hi")
}=========================================分割线//定义一个函数：专门用来各国人打招呼的函数，接收具备SayHello接口的能力的变量：
func greet(s SayHello){s.sayHello()
}
=========================================分割线//测试
func main(){//创建一个中国人：c := Chinese{}//创建一个美国人：a := American{}//美国人打招呼：greet(a)//中国人打招呼：greet(c)
}

2、接口

• 接口中不能包含任何变量
• 接口中定义一组方法，但不需要实现
• Go中没有implements关键字，实现接口要实现所有的方法才是实现，即Go的实现是基于方法的

3、接口的注意点

1）接口本身不能创建实例，但是可以指向一个实现了该接口的自定义类型的变量

//直接用接口创建实例并调用方法，编译报错
//var s SayHello
//s.sayHello()
c := Chinese{}
var s SayHello = c
s.sayHello()

2）只要是自定义数据类型，就可以实现接口，不仅仅是结构体类型

3）一个自定义类型可以实现多个接口

package main
import "fmt"type AInterface interface{a()
}type BInterface interface{b()
}type Stu struct{
}//实现接口A（的方法）
func (s Stu) a(){fmt.Println("aaaa")
}
//实现接口B（的方法）
func (s Stu) b(){fmt.Println("bbbb")
}func main(){var s Stuvar a AInterface = s		//注意这里的赋值var b BInterface = s		//注意这里的赋值a.a()b.b()
}

4）一个接口(比如A接口)可以继承多个别的接口(比如B,C接口)，这时如果要实现A接口,也必须将B,C接口的方法也全部实现

package main
import "fmt"
//C接口
type CInterface interface{c()
}//B接口
type BInterface interface{b()
}//A接口继承了B、C接口，且有自己的方法a()
type AInterface interface{BInterfaceCInterfacea()
}//Stu结构体实现A接口，也要去实现B、C接口的方法
type Stu struct{
}func (s Stu) a(){fmt.Println("a")
}
func (s Stu) b(){fmt.Println("b")
}
func (s Stu) c(){fmt.Println("c")
}
func main(){var s Stuvar a AInterface = sa.a()a.b()a.c()
}

5）interface类型默认是一个指针(引用类型)，如果没有对interface初始化就使用,那么会输出nil

6）空接口没有任何方法,所以可以理解为所有类型都实现了空接口，也可以理解为我们可以把任何一个变量赋给空接口

注意上面两种空接口类型的写法，一种是自己定义一个：

type E interface{
}Var e E = s

也可：

var e interface{} = s

4、多态

面向对象的最后一个特征：多态，即多种形态，编译时、运行时两种状态。Go中的多态特征是通过接口实现的，可以按照统一的接口来调用不同的实现。如上面Part1中的SayHello，形参就是一个父类接口：

再比如定义SayHello数组，存放中国人结构体、美国人结构体

5、断言

直接判断是否是该类型的变量，Java的instanceOf

value, ok := element.(T)

即，element是否为T类型，是转为T，值为value，且ok为true

package main
import "fmt"
//接口的定义：定义规则、定义规范，定义某种能力：
type SayHello interface{//声明没有实现的方法：sayHello()
}
//接口的实现：定义一个结构体：
//中国人：
type Chinese struct{name string
}
//实现接口的方法---》具体的实现：
func (person Chinese) sayHello(){fmt.Println("你好")
}
//中国人特有的方法
func (person Chinese) niuYangGe(){fmt.Println("东北文化-扭秧歌")
}
//接口的实现：定义一个结构体：
//美国人：
type American struct{name string
}
//实现接口的方法---》具体的实现：
func (person American) sayHello(){fmt.Println("hi")
}
//定义一个函数：专门用来各国人打招呼的函数，接收具备SayHello接口的能力的变量：
func greet(s SayHello){s.sayHello()//断言：ch,flag := s.(Chinese)//看s是否能转成Chinese类型并且赋给ch变量,flag是判断是否转成功if flag == true{ch.niuYangGe()}else{fmt.Println("美国人不会扭秧歌")}fmt.Println("打招呼。。。")
}
func main(){//创建一个中国人：//c := Chinese{}//创建一个美国人：a := American{}//美国人打招呼：greet(a)//中国人打招呼：//greet(c)
}

关键点：

6、Type Switch

一种特殊的switch语句，用type关键字。用法：

//定义一个函数：专门用来各国人打招呼的函数，接收具备SayHello接口的能力的变量：
func greet(s SayHello){s.sayHello()switch s.(type){//type属于go中的一个关键字，固定写法case Chinese:ch := s.(Chinese)ch.niuYangGe()case American:am := s.(American)am.disco()}fmt.Println("打招呼。。。")
}

完整示例：

package main
import "fmt"
//接口的定义：定义规则、定义规范，定义某种能力：
type SayHello interface{//声明没有实现的方法：sayHello()
}
//接口的实现：定义一个结构体：
//中国人：
type Chinese struct{name string
}
//实现接口的方法---》具体的实现：
func (person Chinese) sayHello(){fmt.Println("你好")
}
//中国人特有的方法
func (person Chinese) niuYangGe(){fmt.Println("东北文化-扭秧歌")
}
//接口的实现：定义一个结构体：
//美国人：
type American struct{name string
}
//实现接口的方法---》具体的实现：
func (person American) sayHello(){fmt.Println("hi")
}
func (person American) disco(){fmt.Println("野狼disco")
}
//定义一个函数：专门用来各国人打招呼的函数，接收具备SayHello接口的能力的变量：
func greet(s SayHello){s.sayHello()switch s.(type){//type属于go中的一个关键字，固定写法case Chinese:ch := s.(Chinese)ch.niuYangGe()case American:am := s.(American)am.disco()}fmt.Println("打招呼。。。")
}
func main(){//创建一个中国人：c := Chinese{}//创建一个美国人：//a := American{}//美国人打招呼：//greet(a)//中国人打招呼：greet(c)
}