interface

    简单的说，interface是一组method签名的组合，通过interface来定义对象的一组行为。

    前面例子中Student和Employee都能SayHi，虽然他们的内部实现不一样，但是那不重要，重要的是他们都能say hi

    继续做更多的扩展，Student和Employee实现另一个方法Sing，然后Student实现方法BorrowMoney而Employee实现SpendSalary。

    这样Student实现了三个方法：SayHi、Sing、BorrowMoney；而Employee实现了SayHi、Sing、SpendSalary。

    上面这些方法的组合称为interface(被对象Student和Employee实现)。例如Student和Employee都实现了interface：SayHi和Sing，也就是这两个对象是该interface类型。而Employee没有实现这个interface：SayHi、Sing和BorrowMoney，因为Employee没有实现BorrowMoney这个方法。

    interface类型

    interface类型定义了一组方法，如果某个对象实现了某个接口的所有方法，则此对象就实现了此接口。详细的语法参考下面这个例子

    通过上面的代码可以知道，interface可以被任意的对象实现。看到上面的Men interface被Human、Student和Employee实现。同理，一个对象可以实现任意多个interface，例如上面的Student实现了Men和YoungChap两个interface。

    最后，任意的类型都实现了空interface(这样定义：interface{})，也就是包含0个method的interface。

    那么interface里面到底能存什么值呢？如果定义了一个interface的变量，那么这个变量里面可以存实现这个interface的任意类型的对象。例如上面例子中，定义了一个Men interface类型的变量m，那么m里面可以存Human、Student或者Employee值。

    来看一下下面这个例子:

    1. package main
    2. import "fmt"
    3. type Human struct {
    4.     name string
    5.     age int
    6.     phone string
    7. }
    8. type Student struct {
    9.     Human //匿名字段
    10.     school string
    11.     loan float32
    12. }
    13. type Employee struct {
    14.     Human //匿名字段
    15.     company string
    16.     money float32
    17. }
    18. //Human实现SayHi方法
    19. func (h Human) SayHi() {
    20.     fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
    21. }
    22. //Human实现Sing方法
    23. func (h Human) Sing(lyrics string) {
    24.     fmt.Println("La la la la...", lyrics)
    25. }
    27. func (e Employee) SayHi() {
    28.     fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
    29.         e.company, e.phone)
    30.     }
    31. // Interface Men被Human,Student和Employee实现
    32. // 因为这三个类型都实现了这两个方法
    33. type Men interface {
    34.     SayHi()
    35.     Sing(lyrics string)
    36. }
    37. func main() {
    38.     mike := Student{Human{"Mike", 25, "222-222-XXX"}, "MIT", 0.00}
    39.     paul := Student{Human{"Paul", 26, "111-222-XXX"}, "Harvard", 100}
    40.     tom := Employee{Human{"Tom", 37, "222-444-XXX"}, "Things Ltd.", 5000}
    41.     //定义Men类型的变量i
    42.     var i Men
    43.     //i能存储Student
    44.     i = mike
    45.     fmt.Println("This is Mike, a Student:")
    46.     i.SayHi()
    47.     i.Sing("November rain")
    48.     //i也能存储Employee
    49.     i = tom
    50.     fmt.Println("This is tom, an Employee:")
    51.     i.SayHi()
    52.     i.Sing("Born to be wild")
    53.     //定义了slice Men
    54.     fmt.Println("Let's use a slice of Men and see what happens")
    55.     x := make([]Men, 3)
    56.     //这三个都是不同类型的元素，但是他们实现了interface同一个接口
    57.     x[0], x[1], x[2] = paul, sam, mike
    58.     for _, value := range x{
    59.         value.SayHi()
    60.     }
    61. }

    通过上面的代码，发现interface就是一组抽象方法的集合，它必须由其他非interface类型实现，而不能自我实现， Go通过interface实现了duck-typing:即”当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子”。

    空interface

    空interface(interface{})不包含任何的method，正因为如此，所有的类型都实现了空interface。空interface对于描述起不到任何的作用(因为它不包含任何的method），但是空interface需要存储任意类型的数值的时候相当有用，因为它可以存储任意类型的数值。它有点类似于C语言的void*类型。

    1. // 定义a为空接口
    2. var a interface{}
    3. var i int = 5
    4. s := "Hello world"
    5. // a可以存储任意类型的数值
    6. a = i
    7. a = s

    一个函数把interface{}作为参数，那么他可以接受任意类型的值作为参数，如果一个函数返回interface{},那么也就可以返回任意类型的值。是不是很有用啊！

    interface的变量可以持有任意实现该interface类型的对象，这给编写函数(包括method)提供了一些额外的思考，是不是可以通过定义interface参数，让函数接受各种类型的参数。

    举个例子：fmt.Println是常用的一个函数，是否注意到它可以接受任意类型的数据。打开fmt的源码文件，会看到这样一个定义:

    也就是说，任何实现了String方法的类型都能作为参数被fmt.Println调用,来试一试

    1. package main
    2. import (
    3.     "fmt"
    4.     "strconv"
    5. )
    6. type Human struct {
    7.     name string
    8.     age int
    9.     phone string
    10. }
    11. // 通过这个方法 Human 实现了 fmt.Stringer
    12. func (h Human) String() string {
    13.     return "❰"+h.name+" - "+strconv.Itoa(h.age)+" years -  ✆ " +h.phone+"❱"
    14. }
    15. func main() {
    17.     fmt.Println("This Human is : ", Bob)

    现在再回顾一下前面的Box示例，发现Color结构也定义了一个method：String。其实这也是实现了fmt.Stringer这个interface，即如果需要某个类型能被fmt包以特殊的格式输出，就必须实现Stringer这个接口。如果没有实现这个接口，fmt将以默认的方式输出。

    1. //实现同样的功能
    2. fmt.Println("The biggest one is", boxes.BiggestsColor().String())
    3. fmt.Println("The biggest one is", boxes.BiggestsColor())

    注：实现了error接口的对象（即实现了Error() string的对象），使用fmt输出时，会调用Error()方法，因此不必再定义String()方法了。

    interface变量存储的类型

    • Comma-ok断言

    Go语言里面有一个语法，可以直接判断是否是该类型的变量： value, ok = element.(T)，这里value就是变量的值，ok是一个bool类型，element是interface变量，T是断言的类型。

    如果element里面确实存储了T类型的数值，那么ok返回true，否则返回false。

    通过一个例子来更加深入的理解。

    是否注意到了多个if里面，if里面允许初始化变量。断言的类型越多，那么if else也就越多，所以才引出了下面要介绍的switch。

    • switch测试

    重写上面的这个实现

    1. package main
    2. import (
    3.     "fmt"
    4.     "strconv"
    5. )
    6. type Element interface{}
    7. type List [] Element
    8. type Person struct {
    9.     name string
    10.     age int
    11. }
    12. //打印
    13. func (p Person) String() string {
    14.     return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)"
    15. }
    16. func main() {
    17.     list := make(List, 3)
    18.     list[0] = 1 //an int
    19.     list[1] = "Hello" //a string
    20.     list[2] = Person{"Dennis", 70}
    21.     for index, element := range list{
    22.         switch value := element.(type) {
    23.             case int:
    24.             fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
    25.             case string:
    26.             fmt.Printf("list[%d] is a string and its value is %s\n", index, value)
    27.             case Person:
    28.             fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)
    29.             default:
    30.             fmt.Println("list[%d] is of a different type", index)
    31.         }
    32.     }
    33. }

    这里有一点需要强调的是：element.(type)语法不能在switch外的任何逻辑里面使用，如果要在switch外面判断一个类型就使用comma-ok。

    Go里面真正吸引人的是它内置的逻辑语法，就像在学习Struct时学习的匿名字段，那么相同的逻辑引入到interface里面，更加完美了。如果一个interface1作为interface2的一个嵌入字段，那么interface2隐式的包含了interface1里面的method。

    可以看到源码包container/heap里面有这样的一个定义

    1. type Interface interface {
    2.     sort.Interface //嵌入字段sort.Interface
    3.     Push(x interface{}) //a Push method to push elements into the heap
    4.     Pop() interface{} //a Pop elements that pops elements from the heap
    5. }

    看到sort.Interface其实就是嵌入字段，把sort.Interface的所有method给隐式的包含进来了。也就是下面三个方法：

    1. // io.ReadWriter
    2. type ReadWriter interface {
    3.     Reader