接口简介
Go 语言不是一种“传统” 的面向对象编程语言， 所以 Go 语言并没有类和继承的概念。但是 Go 语言里有非常灵活的接口概念，通过它可以实现很多面向对象的特性。
在Go语言的实际编程中，几乎所有的数据结构都围绕接口展开，接口是Go语言中所有数据结构的核心。
接口是一种契约，实现类型必须满足它，它描述了类型的行为，规定类型可以做什么。接口彻底将类型能做什么，以及如何做分离开来，使得相同接口的变量在不同的时刻表现出不同的行为。
Go语言中的接口是一些方法的集合（method set），它指定了对象的行为：如果它（任何数据类型）可以做这些事情，那么它就可以在这里使用。看一种类型是不是“实现”了一个接口，就得看这种类型是不是实现了接口中定义的所有方法。
什么是interface
简单的说，interface是一组method签名的组合，我们通过interface来定义对象的一组行为。
接口定义中不能包含变量。
/* 定义接口 */
type interface_name interface {
method_name1 [return_type]
method_name2 [return_type]
method_name3 [return_type]
...
method_namen [return_type]
}
/* 定义结构体 */
type struct_name struct {
/* variables */
}
/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
/* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
/* 方法实现*/
}
interface类型
interface类型定义了一组方法，如果某个对象实现了某个接口的所有方法，则此对象就实现了此接口。
在定义了一个接口之后，一般使用一个自定义结构体（struct）去实现接口中的方法。
interface可以被任意的对象实现，一个对象可以实现任意多个interface！
对于某个接口的同一个方法，不同的结构体（struct）可以有不同的实现，例如：
type Phone interface {
call()
}
type NokiaPhone struct {}
type IPhone struct {}
func (nokiaPhone NokiaPhone) call() {
fmt.Println("I am Nokia, I can call you!")
}
func (iPhone IPhone) call() {
fmt.Println("I am iPhone, I can call you!")
}
func main() {
var phone Phone
phone = new(NokiaPhone)
phone.call()
phone = new(IPhone)
phone.call()
}
interface值
不像大多数面向对象编程语言，在 Go 语言中接口可以有值。假设有个接口定义如下：
type Namer interface {
Method1(param_list) return_type
Method2(param_list) return_type
...
}
那么定义var ai Namer中，ai是有值的，只不过这个时候，ai是接口的“零值”状态，值是 nil。
事实上 ，Go 语言中接口不仅有值，还能进行接口赋值，接口赋值分为以下两种情况：
1. 将对象实例赋值给接口。
2. 将一个接口赋值给另一个接口。
其中：
将对象实例赋值给接口要求对象实现了接口的所有方法；
接口之间的赋值要求接口A中定义的所有方法，都在接口B中有定义，那么B接口的实例可以赋值给A的对象。反之不一定成立，除非A和B定义的方法完全一样（顺序不要求），这时A和B等价，可以相互赋值。
示例代码如下：
type Shaper interface {
Area() float32
}
type Square struct {
side float32
}
func (sq *Square) Area() float32 {
return sq.side * sq.side
}
func main() {
sq1 := new(Square)
sq1.side = 5
// 赋值方法1：
//var areaIntf Shaper
// areaIntf = sq1
// 更短的赋值方法2:
// areaIntf := Shaper(sq1)
// 最简洁的赋值方法3：
areaIntf := sq1
fmt.Printf("The square has area: %f\n", areaIntf.Area())
}
上面的程序定义了一个结构体 Square 和一个接口 Shaper，接口有一个方法 Area()。
在main() 方法中创建了一个Square的实例。在主程序外边定义了一个接收者类型是 Square 方法的 Area()，用来计算正方形的面积：结构体 Square 实现了接口 Shaper 。
所以可以将一个 Square类型的变量赋值给一个接口类型的变量：areaIntf = sq1 。
现在接口变量包含一个指向Square 变量的引用，通过 areaIntf 可以调用Square上的方法 Area()。
空interface
空interface(interface{})不包含任何的method，所有的类型都实现了空interface。
空interface对于描述起不到任何的作用（因为它不包含任何的method），但是空interface在我们需要存储任意类型的数值的时候相当有用，因为它可以存储任意类型的数值。
//定义a为空接口
var a interface{}
var i int = 5
s := "Hello world"
//a可以存储任意类型的数值
a = i
a = s
一个函数把interface{}作为参数，那么他可以接受任意类型的值作为参数，如果一个函数返回interface{}，那么也就可以返回任意类型的值。
interface函数参数
interface的变量可以持有任意实现该interface类型的对象，我们可以通过定义interface参数，让函数接受各种类型的参数。
interface存储变量的类型
interface的变量里面可以存储任意类型的数值，那么我们怎么反向知道这个变量里面实际保存了的是哪个类型的对象呢？
1、Comma-ok断言
value, ok = element.(T)
value就是变量的值，ok是一个bool类型，element是interface变量，T是断言的类型。
如果element里面确实存储了T类型的数值，那么ok返回true，否则返回false。
import (
"fmt"
"strconv"
)
type Element interface{}
type List []Element
type Person struct {
name string
age int
}
// 定义了String方法，实现了fmt.Stringer
func (p Person) String() string {
return "(name: " + p.name + " = age: " + strconv.Itoa(p.age) + " years）"
}
func main() {
list := make(List, 3)
list[0] = 1
list[1] = "Hello"
list[2] = Person{"Jeny", 70}
for index, element := range list {
if value, ok := element.(int); ok {
fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
} else if value, ok := element.(string); ok {
fmt.Printf("list[%d] is an int and its value is %s\n", index, value)
} else if value, ok := element.(Person); ok {
fmt.Printf("list[%d] is an int and its value is %s\n", index, value)
} else {
fmt.Printf("list[%d] is of a different type\n", index)
}
}
}
2、switch测试
func main() {
list := make(List, 3)
list[0] = 1
list[1] = "Hello"
list[2] = Person{"Jeny", 70}
for index, element := range list {
switch value := element.(type) {
case int:
fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
case string:
fmt.Printf("list[%d] is an int and its value is %s\n", index, value)
case Person:
fmt.Printf("list[%d] is an int and its value is %s\n", index, value)
default:
fmt.Printf("list[%d] is of a different type\n", index)
}
}
}
注意：`element.(type)`语法不能在switch外的任何逻辑里面使用，如果你要在switch外面判断一个类型就使用`comma-ok`。
嵌入interface
源码包container/heap里面有这样的一个定义：
type Interface interface {
sort.Interface // 嵌入字段sort.Interface
Push(x interface{})
Pop() interface{}
}
sort.Interface其实就是嵌入字段，把sort.Interface的所有method给隐式的包含进来了。