Go语言中接口是一组方法的集合，它是Go语言的重要组成部分，面向接口编程使得代码之间的耦合度能够更低，并且更加方便测试。
Go中的接口
Go中的接口分为两种，一种就是如上所说的方法的集合，另一种则是类型。
//
// @Description: 定义接口-人
//
type person interface { // 第一种，所谓方法的集合
eat()
printName() string
}
var val interface{} // 第二种，interface{}作为一种类型
隐式实现
Go中的接口和Java中的不同，Java中需要使用关键字implement来显式的声明一个类实现了某一个接口，而Go中则不需要。
与Java中Class对应，Go中则使用了struct结构体来表达类的概念，在Go中，任意一个struct实现了接口中的所有方法，那么则认为该struct实现了该接口。
type Amy struct {
Name string
Height float64
Weight float64
Age int
}
func (receiver Amy) eat() {
// do sth
}
func (receiver Amy) printName() string {
return receiver.Name
}
接口类型
上面提到接口可以作为类型，更进一步的，接口在一定条件下可以与其他类型相互转换。
type Mike struct {
Name string
}
type Jhon struct {
Name string
}
func (receiver Mike) eat() {
// do sth
}
func (receiver Mike) printName() string {
return receiver.Name
}
func (receiver Jhon) eat() {
// do sth
}
// Jhon这个struct没有实现printName这个方法
//
// @Description: 定义了一个做朋友的函数，接收的参数类型为person接口类型
// @param p1
// @param p2
//
func makeFriends(p1 person, p2 person) {
fmt.Printf("%s and %s are friends now", p1.printName(), p2.printName())
}
func main() {
makeFriends(Amy{Name: "Amy"}, Mike{Name: "Mike"}) // 正常运行打印
// Amy and Mike are friends now
makeFriends(Amy{Name: "Amy"}, Jhon{Name: "Jhon"}) // 编译出错
// cannot use Jhon literal (type Jhon) as type person in argument to makeFriends:
//Jhon does not implement person (missing printName method)
}
上面的代码可以看出来，任意一个实现了person接口的struct都可以转换成person类型（Amy和Mike实现了接口，但是Jhon没有实现，于是报错）
而对于interface{}类型的变量则可以与任意类型进行转换，这里需要注意的是，仅仅是可以转换，而并非等于任意类型。Go中的interface{}和C语言中的void*有些类似，void*可以代表任意类型，但是interface{}只是具备着转换成为任意类型的能力，其本质上仍为interface{}类型。举个例子：
func main() {
var w interface{} // 标记①
w = new(bytes.Buffer) // 标记②
w = new(int) // 标记③
}
在Goland中用debug模式来查看变量w的类型
在标记①处，可以看到w的类型是interface{}，并且值为nil
在标记②处，可以看到w的类型是{interface{}|*bytes.Buffer}，实质上仍为一个interface{}类型。注：关于interface{}底层源码可以参考此篇文章
在标记③处，可以看到w的类型是{interface{}|*int}
类型断言
类型断言是一个使用在接口值上的操作。语法上它看起来像x.(T)被称为断言类型，这里x表示一个接口的类型和T表示一个类型。一个类型断言检查它操作对象的动态类型是否和断言的类型匹配。 引用自Go语言圣经（中文版）
当interface{}类型作为函数参数时，可以传递任意类型的变量，参数在传递过程中会进行隐式的类型转换，转换成interface{}|T类型。由于传入参数类型的不可控性，因此常常会在函数内进行类型断言(就是常说的类型判断)。
func useInterface(i interface{}) {
// 第一种方式，适合用于判断i是否为某一类型
if convert, ok := i.(float64); ok {
// do sth
}
// 第二种方式，使用switch来进行判断
switch x := i.(type) {
case float64:
// do sth
case string:
// do sth
case int32:
// do sth
}
}
如果直接使用x.(T)进行断言，如果x不是T类型，那么则会出现panic错误，这显然是不够优雅的，所以建议尽可能的使用convert, ok := x.(T)或者switch + x.(type)的方式来进行类型断言。
