简单地说，接口就是一组方法签名的组合。我们使用一个接口来识别一个对象能够进行的操作。一个接口可以被任意数量的类型满足，而且一个类型可以实现任意数量的接口。每个类型都实现了一个空接口interface{}。

    如果你声明了一个接口变量，这个变量能够存储任何实现该接口的对象类型。

    1. package main
    3. import "fmt"
    5. type Human struct {
    6.     name  string
    7.     age   int
    8.     phone string
    9. }
    11. type Student struct {
    12.     Human  //an anonymous field of type Human
    13.     school string
    14.     loan   float32
    15. }
    17. type Employee struct {
    18.     Human   //an anonymous field of type Human
    19.     company string
    20.     money   float32
    21. }
    23. //A human method to say hi
    24. func (h Human) SayHi() {
    25.     fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
    26. }
    28. //A human can sing a song
    29. func (h Human) Sing(lyrics string) {
    30.     fmt.Println("La la la la...", lyrics)
    31. }
    33. //Employee's method overrides Human's one
    34. func (e Employee) SayHi() {
    35.     fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
    36.         e.company, e.phone) //Yes you can split into 2 lines here.
    37. }
    39. // Interface Men is implemented by Human, Student and Employee
    40. // because it contains methods implemented by them.
    41. type Men interface {
    42.     SayHi()
    43.     Sing(lyrics string)
    44. }
    46. func main() {
    47.     mike := Student{Human{"Mike", 25, "222-222-XXX"}, "MIT", 0.00}
    48.     paul := Student{Human{"Paul", 26, "111-222-XXX"}, "Harvard", 100}
    49.     sam := Employee{Human{"Sam", 36, "444-222-XXX"}, "Golang Inc.", 1000}
    50.     Tom := Employee{Human{"Sam", 36, "444-222-XXX"}, "Things Ltd.", 5000}
    52.     //a variable of the interface type Men
    53.     var i Men
    55.     //i can store a Student
    56.     i = mike
    57.     fmt.Println("This is Mike, a Student:")
    58.     i.SayHi()
    59.     i.Sing("November rain")
    61.     //i can store an Employee too
    62.     i = Tom
    63.     fmt.Println("This is Tom, an Employee:")
    64.     i.SayHi()
    65.     i.Sing("Born to be wild")
    67.     //a slice of Men
    68.     fmt.Println("Let's use a slice of Men and see what happens")
    69.     x := make([]Men, 3)
    70.     //These elements are of different types that satisfy the Men interface
    71.     x[0], x[1], x[2] = paul, sam, mike
    73.     for _, value := range x {
    74.         value.SayHi()
    75.     }
    76. }

    输出是：

    1. This is Mike, a Student:
    2. Hi, I am Mike you can call me on 222-222-XXX
    3. La la la la... November rain
    4. This is Tom, an Employee:
    5. Hi, I am Sam, I work at Things Ltd.. Call me on 444-222-XXX
    6. La la la la... Born to be wild
    7. Let’s use a slice of Men and see what happens
    8. Hi, I am Paul you can call me on 111-222-XXX
    9. Hi, I am Sam, I work at Golang Inc.. Call me on 444-222-XXX
    10. Hi, I am Mike you can call me on 222-222-XXX

    从上面的代码可以看出，接口类型是一组抽象的方法集，它本身不实现方法或者精确描述数据结构和方法的实现方式。接口本身并不关心到底是什么数据类型实现了它。接口类型的本质就是如果一个数据类型实现了自身的方法集，那么该接口类型变量就能够引用该数据类型的值。

    1.  空接口类型interface{}一个方法签名也不包含，所以所有的数据类型都实现了该方法。

    空接口类型在描述一个对象实例的形式上力不从心，但是当我们需要存储任意数据类型的实例的时候，空接口类型的使用使得我们得心应手。

    Go 接口 - 图1