go语言interface学习

 Go 中的 interface 所具有的最基本的功能：作为一种 abstract type，实现各种 concrete type 的行为统一。

interface是一种类型。只有是实例化后才能调用interface中的方法，没毛病。

interface的定义

基本形式如下；

type (reciever *T) FUNC_NAME (args)  (args...Type) {
    //do something
}

interface内部由0个或者多个方法声明组成：

/* interface可以没有方法声明 */
type USB interface {
}

/* 多个method声明 */
type USB interface {
    Name()
    Age()
    User()
}

也可以嵌套别的interface组合成一个新的interface：

type USB interface {
    Name() string
}

type Computer interface {
    USB
    screen(price int)
}

以上几种方式都是等价的，但是更推崇嵌入的方式。想下为什么？为了更好的实现多态啊。后面讲。

interface的内部实现初探？

我先实例化上面的interface，然后看一下他所占用的内存大小：（我是在64位操作系统上跑的）

var a Computer
fmt.Println("sizeof computer = ", unsafe.Sizeof(a))
/* vsizeof computer =  16 */

实际上，所有的interface实例化后都是一样的大小16字节（64位机）。为什么呢？说明interface存放的是一个固定结构，不然大小肯定会变化，就像任何指针变量在64位机上都占8个字节一样。

 interface存储的是实例化的值

/* declare In interface */
type In interface {
    Name() string
}

/* declare S struct */
type S struct {
    x int32
    y int32
}

/* implement method Name() string with S struct;
 * Now S struct is an instance of In interface
 */
func (s S) Name() string {
    return "interface"
}

/* function print
 * we can pass an instance of in interface,
 * we can pass an instance of S struct, too
 */
func print(in In) {
    fmt.Println(in.Name())
}

func main() {
    s := S{}
    print(s) //ok

    var i In
    i = s
    print(i) //ok
}

interface的重要作用体现在func print(in In)中。如果有多种struct实现了interface的methods，那么以interface为接收类型的函数可以接收所有实现了其方法的对象。

这点有点像C++中的父类指针可以接收子类实例作为参数的用法，C++这种做法实现了运行时的多态。

go和C++有所不同的是，go语言不需要显式的告诉编译器我实现了哪些interface，只需要隐式的默默的去实现某个或某些interface的方法即可。go程序运行时候会自动检查并转换。

注意：switch i.(type)语句结构中不能用fallthrough，具体原因不明，有待深入理解。下面这段代码编译会报错：

switch value.(type) {
    case int:
        fallthrough　　//error
    case int64:
        //......
}

并列写就不会报错了：

switch value.(type) {
    case int, int64:　　　　//ok
        //......
    case int int32:
        //......
}

 空interface

go语言和java一样，支持empty interface。看一下下面代码的执行：

func main() {
    var any interface{}
    any = 1
    fmt.Println(any) //1
    any = nil
    fmt.Println(any) //<nil>
    any = "string"
    fmt.Println(any) //string
    any = S{}
    fmt.Println(any) //{0 0}
}

空的interface没有声明方法，所以所有的类型都实现了interface{}，因此所有类型的instance都能当参数传给interface{}的实例。

这个例子还能看出一个奥妙：

不同的类型，实现了同一个接口，那么如果一个类型的方法是另一个方法的子集，那么可以把大的赋值给小的（是赋值还是引用？要进步深入）。

interface的内部实现再探

既然空的 interface 可以接受任何类型的参数，那么一个 interface{}类型的 slice 是不是就可以接受任何类型的 slice ?

s := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
ss := make([]interface{}, len(s))
ss=s /* error*/
//cannot use s (type []int) as type []interface {} in assignment

竟然报错！！！！go为啥不自动将int转换成interface{}呢？

参考：

Go Data Structures: Interfaces