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) //

     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

巴特西

go语言interface学习