Golang中的Interface详解 Interface

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里即可。

空Interface

interface{} 没有任何方法,按照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
}
Interface的Receiver的选择

在了解这个之前,我们先来说说,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)
}
Reference