实践一：

需求：

给Phone结构体增加一个特有方法 call() ，当Usb接口接收的是 Phone 变量的时候，还需要调用 call() 方法
image.png

代码

  1. // 该案例展示 多态数组 类型断言
  2. package main
  4. import (
  5.     "fmt"
  6. )
  8. // 定义 Usb 接口， 有两个方法(行为)
  9. type Usb interface {
  10.     start()
  11.     stop()
  12. }
  14. // 定义 Phone 结构体， 并实现 start, stop 方法
  15. type Phone struct {
  16.     Name string
  17. }
  19. // 值接收者
  20. // Phone 类型实现了 Usb 接口 (就是实现了 Usb 接口的所有方法)
  21. func (phone Phone) start() {
  22.     fmt.Printf("%v开始--- \n", phone.Name)
  23. }
  24. func (phone Phone) stop() {
  25.     fmt.Printf("%v停止--- \n", phone.Name)
  26. }
  28. // Phone 结构体特有方法
  29. func (phone Phone) call() {
  30.     fmt.Printf("%v 手机打电话--- \n", phone.Name)
  31. }
  33. // 定义 Camera 结构体， 并实现 start, stop 方法
  34. type Camera struct {
  35.     Name string
  36. }
  38. // 指针接收者
  39. // Camera 类型实现了 Usb 接口 (就是实现了 Usb 接口的所有方法)
  40. func (camera Camera) start() {
  41.     fmt.Printf("%v开始--- \n", camera.Name)
  42. }
  43. func (camera Camera) stop() {
  44.     fmt.Printf("%v停止--- \n", camera.Name)
  45. }
  47. // 定义 Computer 结构体, 并实现 Working 方法
  48. type Computer struct {
  49. }
  51. // 编写 Working 方法，接收一个 Usb 接口类型的变量，
  52. // 只要一个类型实现了某个接口，那么所有使用这个接口的地方，都支持这种类型的值
  53. //  (比如： 实参 phone, camera, 都是 Usb 类型来接收， 这就是多态)
  54. func (computer *Computer) Working(usb Usb) {
  55.     usb.start()
  56.     // type Usb has no field or method call
  57.     // usb.call() // err
  59.     // 类型断言 调用 Phone.call()
  60.     // 如果 usb 是指向 Phone 类型的变量，就把 usb 转化成 Phone 类型，并调用 Phone.call()
  61.     if phone, ok := usb.(Phone); ok {
  62.         phone.call()
  63.     }
  64.     usb.stop()
  65. }
  67. func main() {
  68.     // 定义 Usb 接口数组
  69.     var usbArr [3]Usb
  70.     fmt.Println("usbArr = ", usbArr) // [<nil> <nil> <nil>]
  71.     /*
  72.         以下，接口类型的数组，存放了不同类型的元素(Phone, Camera...)
  73.         这里就体现了多态数组
  74.     */
  75.     usbArr[0] = Phone{"华为"}
  76.     usbArr[1] = Camera{"尼康"}
  77.     usbArr[2] = Phone{"苹果"}
  78.     fmt.Println("usbArr = ", usbArr) // [{华为} 0xc00004c240 {苹果}]
  80.     var computer Computer
  81.     for _, v := range usbArr {
  82.         fmt.Println()
  83.         computer.Working(v)
  84.     }
  85. }
  88. /*
  89. usbArr =  [<nil> <nil> <nil>]
  90. usbArr =  [{华为} {尼康} {苹果}]
  92. 华为开始---
  93. 华为 手机打电话---
  94. 华为停止---
  96. 尼康开始---
  97. 尼康停止---
  99. 苹果开始---
  100. 苹果 手机打电话---
  101. 苹果停止---
  102. */

实践二：

需求：

写一个函数，循环判断传入参数的类型

代码

  1. // 编写函数，判断参数是什么类型
  2. package main
  4. import (
  5.     "fmt"
  6. )
  8. // 定义 Student 类型
  9. type Student struct{}
  11. // 可以接收多个不同类型的参数
  12. func JudgeType(items ...interface{}) {
  13.     for i, v := range items {
  14.         i = i + 1
  15.         // 类型断言
  16.         switch v.(type) {
  17.         case bool:
  18.             fmt.Printf("第%v个参数是 bool 类型，值：%v \n", i, v)
  19.         case float32:
  20.             fmt.Printf("第%v个参数是 float32 类型，值：%v \n", i, v)
  21.         case float64:
  22.             fmt.Printf("第%v个参数是 float64 类型，值：%v \n", i, v)
  23.         case int, int16, int32, int64:
  24.             fmt.Printf("第%v个参数是 整数 类型，值：%v \n", i, v)
  25.         case string:
  26.             fmt.Printf("第%v个参数是 string 类型，值：%v \n", i, v)
  27.         case Student:
  28.             fmt.Printf("第%v个参数是 Student 类型，值：%v \n", i, v)
  29.         case *Student:
  30.             fmt.Printf("第%v个参数是 *Student 类型，值：%v \n", i, v)
  31.         default:
  32.             fmt.Printf("第%v个参数类型不确定，值：%v \n", i, v)
  33.         }
  34.     }
  35. }
  37. func main() {
  38.     var n1 float32 = 1.1
  39.     var n2 float64 = 2.1
  40.     var name string = "tom"
  41.     address := "北京"
  42.     n3 := 64
  43.     stu1 := Student{}
  44.     stu2 := &Student{}
  45.     JudgeType(n1, n2, name, address, n3, stu1, stu2)
  47.     var a interface{}
  48.     var b *interface{}
  49.     fmt.Printf("a 类型： %T, 值： %v \n", a, a) // a 类型： <nil>, 值： <nil>
  50.     fmt.Printf("b 类型： %T, 值： %v \n", b, b) // b 类型： *interface {}, 值： <nil>
  51. }