Go 语言提供了另外一种数据类型即接口，它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口

    1. // 定义接口
    2. type interface_name interface {
    3.    method_name1 [return_type]
    4.    method_name2 [return_type]
    5.    method_name3 [return_type]
    6.    ...
    7.    method_namen [return_type]
    8. }
    10. // 实现接口方法
    11. func (struct_name_variable struct_name) method_name1() [return_type] {
    12.    // 方法实现
    13. }
    17. // 定义结构体
    18. type struct_name struct {
    19.    // variables
    20. }
    22. func (struct_name_variable struct_name) method_namen() [return_type] {
    23.    // 方法实
    24. }
    1. package main
    2. import (
    3.     "fmt"
    4. )
    6. type Phone interface { 
    7.    call() string 
    8.    say() 
    9. }
    11. type NokiaPhone struct { 
    12.     name string
    13. }
    14. func (nokiaPhone NokiaPhone) say() {
    15.     fmt.Println("Hello, I am Nokia")
    16. }
    17. func (nokiaPhone NokiaPhone) call() string {
    18.     return "I am Nokia, I can call you!"
    19. }
    22. type IPhone struct {
    23.     name string
    24.  }
    25. func (iPhone IPhone) say(){
    26.    fmt.Println("Hello, I am iPhone")
    27. }
    28. func (iPhone IPhone) call() string{
    29.      return "I am iPhone, I can call you!"
    30. }
    32. func main() {
    33.     var nokiaPhone NokiaPhone
    34.     nokiaPhone = NokiaPhone{name:"nokiaPhone"}
    35.     fmt.Println(nokiaPhone.name)
    36.     nokiaPhone.call()
    37.     nokiaPhone.say()
    39.     i := IPhone{name:"张三"}
    40.     var iphone Phone = i
    41.     // iphone = new(IPhone)
    42.     // iphone = &IPhone{name:"张三"} //注意iphone = new(IPhone)也可以写作前面这样的
    43.     fmt.Println(i.name)
    44.     iphone.call()
    45.     iphone.say()
    46.     i.say()
    48. }
    50. /* 
    51. 在上面的例子中，我们定义了一个接口Phone，接口里面有一个方法call()。
    52. 然后我们在main函数里面定义了一个Phone类型变量，
    53. 并分别为之赋值为NokiaPhone和IPhone。然后调用call()方法，输出结果如下：
    54. I am Nokia, I can call you!
    55. I am iPhone, I can call you! 
    56. */
    1. package main
    2. import "fmt"
    5. // Interface Men被Human,Student和Employee实现
    6. // 因为这三个类型都实现了这两个方法
    7. type Men interface {
    8.     SayHi()
    9.     Sing(lyrics string)
    10. }
    12. type Human struct {
    13.     name string
    14.     age int
    15.     phone string
    16. }
    18. type Student struct {
    19.     Human //匿名字段
    20.     school string
    21.     loan float32
    22. }
    24. type Employee struct {
    25.     Human //匿名字段
    26.     company string
    27.     money float32
    28. }
    30. //Human实现SayHi方法
    31. func (h Human) SayHi() {
    32.     fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
    33. }
    35. //Human实现Sing方法
    36. func (h Human) Sing(lyrics string) {
    37.     fmt.Println("La la la la...", lyrics)
    38. }
    40. //Employee重载Human的SayHi方法
    41. func (e Employee) SayHi() {
    42.     fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
    43.         e.company, e.phone)
    44.     }
    48. func main() {
    49.     mike := Student{Human{"Mike", 25, "222-222-XXX"}, "MIT", 0.00}
    50.     paul := Student{Human{"Paul", 26, "111-222-XXX"}, "Harvard", 100}
    51.     sam := Employee{Human{"Sam", 36, "444-222-XXX"}, "Golang Inc.", 1000}
    52.     Tom := Employee{Human{"Tom", 37, "222-444-XXX"}, "Things Ltd.", 5000}
    54.     //定义Men类型的变量i
    55.     var i Men
    57.     //i能存储Student
    58.     i = mike
    59.     fmt.Println("This is Mike, a Student:")
    60.     i.SayHi()
    61.     i.Sing("November rain")
    63.     //i也能存储Employee
    64.     i = Tom
    65.     fmt.Println("This is Tom, an Employee:")
    66.     i.SayHi()
    67.     i.Sing("Born to be wild")
    69.     //定义了slice Men
    70.     fmt.Println("Let's use a slice of Men and see what happens")
    71.     x := make([]Men, 3)
    72.     //这三个都是不同类型的元素，但是他们实现了interface同一个接口
    73.     x[0], x[1], x[2] = paul, sam, mike
    75.     for _, value := range x{
    76.         value.SayHi()
    77.     }
    78. }