Interfaces in Go provide a way to specify the behavior of an object
这是"Effective go" 中对interface的定义。Golang的多态是根据duck typing（你看着像，我就认为你是）的方式来实现。举个例子：
func main() {
fishObj := new(fish)
dogObj := new(dog)
var duckObj duck = fishObj
duckObj.eat()
var duckObj1 duck = dogObj
duckObj1.eat()
}
type duck interface {
eat()
}
type fish struct {
}
func (f *fish) eat() {
fmt.Println("fish eat")
}
type dog struct {
}
func (f *dog) eat() {
fmt.Println("dog eat")
}
fish eat
dog eat
fish和dog 都是实现了duck的eat函数，golang就认为fish和dog继承了duck，并可以做类型转换，那么问题来了，golang时候怎么知道调用的是哪个函数呢？要回答这个问题，必须从interface的内存结构开始讲起。
type Binary uint64
func (i Binary) String() string {
return strconv.Uitob64(i.Get(), 2)
}
func (i Binary) Get() uint64 {
return uint64(i)
}
这个Binary实现了Stringer的String接口，将b转换为stringer会发生什么事情呢，如图：
在执行了s:=Stringer(b)后，s的结构包含两个部分，一个是itable的指针，另外一个是存储binary值得指针。itable里面包含了一个所属的真正类型Type，调用s.(type)可得。另外还包含了一个调用函数指针列表，这里的函数列表必须和Stringer的一样。可以看到调用s.String() 其实就相当于s.tab->fun[0](s.data)。那么itable是怎么生成的呢？
首先编译器会为interface类型生成method table list，在运行时态，具体的实现类，会去interface的method table list里去匹配这些方法，并将函数指针并记录到itable，另外为了节省计算时间，匹配信息也会缓存起来，下次就不用再去找寻匹配。
这与C++的多态实现可以对比一下，C++也会生成method table list，不过继承关系是确定的，所以不用去匹配，只需要在运行期间，将具体实现类的函数地址写入到vtable里即可。
空Interfaceinterface{} 没有任何方法，按照duck type的原则，所有类型都可以转为interface{}，经常你会看到如下代码：
var value interface{} // Value provided by caller.
switch str := value.(type) {
case string:
return str
case Stringer:
return str.String()
}
因为这个特性interface{}，大量的用于函数参数，以及函数返回。其实有点像C++的Template的实现，对具体类型进行抽象。
不过这里要强调注意[]interface{}，这是interface{}的slice，不是interface{}，所以不能代表所有类型。下面的这种写法就是典型的错误写法。
var dataSlice []int = foo()
var interfaceSlice []interface{} = dataSlice
正确的写法应该是：
var dataSlice []int = foo()
var interfaceSlice []interface{} = make([]interface{}, len(dataSlice))
for i, d := range dataSlice {
interfaceSlice[i] = d
}
在了解这个之前，我们先来说说，receiver的两种情况，一个是value实现，一个是pointer实现。
func main() {
fishObj := new(fish)
dogObj := new(dog)
var duckObj duck = fishObj
duckObj.eat()
fmt.Println("fish food:", fishObj.Food)
var duckObj1 duck = dogObj
duckObj1.eat()
fmt.Println("dog food:", dogObj.Food)
}
type duck interface {
eat()
}
type fish struct {
Food string
}
func (f fish) eat() {
f.Food = "small fish"
fmt.Println("fish eat", f.Food)
}
type dog struct {
Food string
}
func (d *dog) eat() {
d.Food = "bone"
fmt.Println("dog eat", d.Food)
}
fish eat small fish
fish food:
dog eat bone
dog food: bone
通过上面例子可以看出，采用pointer的dog，Food修改对外是可见的，而采用value的fish，Food修改对外是不可见，可以理解为是一种拷贝。那么现在我们来理解interface的receiver的选择。
func main() {
animals := []duck{dog{}, fish{}}
for _, animal := range animals {
animal.eat()
}
}
type duck interface {
eat()
}
type fish struct {
Food string
}
func (f fish) eat() {
f.Food = "small fish"
fmt.Println("fish eat", f.Food)
}
type dog struct {
Food string
}
func (d *dog) eat() {
d.Food = "bone"
fmt.Println("dog eat", d.Food)
}
这个代码其实会报类似这种错误：
cannot use (dog literal) (value of type dog) as duck value in array or slice literal: missing method eat (eat has pointer receiver)
dog的实现类是一个pointer，而animals的slice是传进去的是一个value，那么这时候就会找出不匹配，编译器就会认为找不到该类型匹配的eat函数。我们需要做如下修改：
animals := []duck{&dog{}, fish{}}
但是还有一种情况，如果receiver都是用value实现的，不管参数是value还是pointer都能ok，原因就是如果传入的是pointer，编译器会自动转换为value。毕竟通过pointer是能找到对应的value，然后在执行copy即可，但是通过copy value是无法找到原始指针的。
func main() {
animals := []duck{&dog{}, &fish{}}
for _, animal := range animals {
animal.eat()
}
}
type duck interface {
eat()
}
type fish struct {
Food string
}
func (f fish) eat() {
f.Food = "small fish"
fmt.Println("fish eat", f.Food)
}
type dog struct {
Food string
}
func (d dog) eat() {
d.Food = "bone"
fmt.Println("dog eat", d.Food)
}