10.1 接口

接口用于实现面向对象中的多态。
接口也是可以嵌套的。
一个接口是很多个方法的集合，但是这些方法不用实现，由实现这个接口的类型去实现。
也就是说，实现了接口里的全部方法，也就实现了这个接口。
下面声明了一个Man接口，man结构体类型实现了Man的全部方法，也就是man实现了接口Man。

  1. package main
  3. import "fmt"
  5. //定义一个Man接口，有两个方法，run和sing
  6. type Man interface {
  7.     run()
  8.     sing()
  9. }
  11. //man结构体
  12. type man struct {
  13. }
  15. //实现run方法
  16. func (m *man) run() {
  17.     fmt.Println("我是双脚走的")
  18. }
  20. //实现sing方法
  21. func (m *man) sing() {
  22.     fmt.Println("我用嘴唱歌")
  23. }
  26. func main() {
  27.     var me Man //声明接口
  28.     var m1 man //声明结构体
  29.     me = &m1 //结构体变量赋值给接口
  30.     me.run()
  31.     me.sing()
  33. }

有什么用呢？这里完全可以不用接口啊，直接用结构体调用方法就可以。

  1.     var m1 man
  2.     m1.run()
  3.     m1.sing()

但是，如果还有其他类型，其他结构体也实现了这个接口，但是不一样的实现。此时，如果调用方法，就是有多少个结构体，就要调用多少次run方法。

  1.     var m1 man
  2.     m1.run()
  3.     m1.sing()
  4.     var m2 woman
  5.     m2.run()
  6.     m2.sing()
  7.     ......

接口的作用就体现出来了，比如上述的例子，还有一个woman结构体也实现了接口，那么，想要它们调用同一个函数时，有不一样的输出，就是接口的作用，多态。

  1. package main
  3. import "fmt"
  5. //定义一个Man接口，有两个方法，run和sing
  6. type Man interface {
  7.     run()
  8.     sing()
  9. }
  11. //man结构体
  12. type man struct {
  13. }
  15. //实现run方法
  16. func (m *man) run() {
  17.     fmt.Println("我是双脚走的")
  18. }
  20. //实现sing方法
  21. func (m *man) sing() {
  22.     fmt.Println("我用嘴唱歌")
  23. }
  25. type woman struct {
  26. }
  28. //实现run方法
  29. func (m *woman) run() {
  30.     fmt.Println("我是单脚走的")
  31. }
  33. //实现sing方法
  34. func (m *woman) sing() {
  35.     fmt.Println("我不用嘴唱歌")
  36. }
  38. func Run(p Man) {
  39.     p.run()
  40.     p.sing()
  41. }
  43. func main() {
  44.     Run(&man{}) //同时调用Run方法
  45.     Run(&woman{}) //各自输出
  46. }

再来一个直观点的例子：
一个Dog接口，两个结构体jinmao和chaiquan，都实现了接口Dog，在add函数种，接收参数类型是接口，然后不同的接口变量调用同一个getage()函数，得到不一样的age，而不用写两遍。这里如果是成千上万个用户，那么效果更加明显，如果没有接口，那么就需要调用成千上万次getage()。

  1. package main
  3. import "fmt"
  5. type Dog interface {
  6.     getage() int
  7. }
  8. type jinmao struct{ age int }
  9. type chaiquan struct{ age int }
  11. func (j jinmao) getage() int {
  12.     return j.age
  13. }
  14. func (c chaiquan) getage() int {
  15.     return c.age
  16. }
  18. func add(s []Dog) {
  19.     var sum int
  20.     for _, i := range s {
  21.         sum += i.getage() //接口的真正意义
  22.     }
  23.     fmt.Println(sum)
  24. }
  26. func main() {
  27.     jj := jinmao{1}
  28.     cc := chaiquan{2}
  29.     sdog := []Dog{jj, cc}
  30.     add(sdog)
  32. }

10.2 类型断言

如何检测和转换接口变量的类型？一个接口类型的变量可以包含任意类型的值，必须有一种方式来检测它的到动态类型，即运行时在变量中存储的值的实际类型。利用类型断言来测试某个时刻接口变量是否包含某个类型的值：

  1.     if v, ok := vari.(*T); ok {
  2.         fmt.Printf("变量var1的类型为: %T", v)
  3.     } else {
  4.         fmt.Println("变量var1不包含类型: ", v) 
  5.     }

例子：

  1. package main
  3. import "fmt"
  5. //定义一个Man接口
  6. type Man interface {
  7.     run()
  8. }
  10. //man结构体
  11. type man struct {
  12.     name string
  13.     age  int
  14. }
  16. //实现run方法
  17. func (m *man) run() {
  18.     fmt.Println("我是双脚走的")
  19. }
  21. type woman struct {
  22. }
  24. //实现run方法
  25. func (m *woman) run() {
  26.     fmt.Println("我是单脚走的")
  27. }
  29. func main() {
  30.     var vari Man
  31.     man1 := man{}
  32.     vari = &man1
  34.     if v, ok := vari.(*man); ok {
  35.         fmt.Printf("变量var1的类型为: %T", v) //*main.man
  36.     } else {
  37.         fmt.Println("变量var1不包含类型: ", v)
  38.     }
  39.     if u, ok := vari.(*woman); ok {
  40.         fmt.Printf("变量var1的类型为: %T", u)
  41.     } else {
  42.         fmt.Printf("变量var1不包含类型: %T", u) //*main.woman
  43.     }
  45. }

10.3 类型判断：type-swith

接口变量的类型也可以使用一种特殊形式的switch来检测，不用if来判断：

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. //定义一个Man接口
  8. type Man interface {
  9.     run()
  10. }
  12. //man结构体
  13. type man struct {
  14.     name string
  15.     age  int
  16. }
  18. //实现run方法
  19. func (m *man) run() {
  20.     fmt.Println("我是双脚走的")
  21. }
  23. type woman struct {
  24. }
  26. //实现run方法
  27. func (m *woman) run() {
  28.     fmt.Println("我是单脚走的")
  29. }
  31. func main() {
  32.     var vari Man
  33.     man1 := man{}
  34.     vari = &man1
  36.     switch t := vari.(type) {
  37.     case *man:
  38.         fmt.Printf("类型%T,值为%v", t, t) //类型*main.man,值为&{ 0}
  39.     case *woman:
  40.         fmt.Printf("类型%T,值为%v", t, t)
  41.     case nil:
  42.         fmt.Printf("nil 值")
  43.     default:
  44.         fmt.Println("未知类型")
  45.     }
  47. }

接口的不写了，没搞懂………