go断言类型实战

一实战1

1 需求

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

2 代码

package main
import (
   "fmt"
)
// 声明/定义一个接口
type Usb interface {
   // 声明了两个没有实现的方法
   Start()
   Stop()
}
type Phone struct {
   name string
}
// 让 Phone 实现 Usb接口的方法
func (p Phone) Start() {
   fmt.Println("手机开始工作。。。")
}
func (p Phone) Stop() {
   fmt.Println("手机停止工作。。。")
}
// Phone 结构体特有的方法
func (p Phone) Call() {
   fmt.Println("手机 在打电话..")
}
type Camera struct {
   name string
}
// 让 Camera 实现 Usb接口的方法
func (c Camera) Start() {
   fmt.Println("相机开始工作。。。")
}
func (c Camera) Stop() {
   fmt.Println("相机停止工作。。。")
}
type Computer struct {
}
func (computer Computer) Working(usb Usb) {
   usb.Start()
   // 当 usb 指向 Phone 结构体变量，调用 Call 方法
   // 类型断言
   if phone, ok := usb.(Phone); ok {
      phone.Call()
   }
   usb.Stop()
}
func main() {
   // 定义一个 Usb 接口数组，可以存放 Phone 和 Camera 的结构体变量
   // 这里体现出多态数组
   var usbArr [3]Usb
   usbArr[0] = Phone{"vivo"}
   usbArr[1] = Phone{"小米"}
   usbArr[2] = Camera{"尼康"}
   // 遍历 usbArr
   // Phone 还有一个特有的方法 call()，遍历 Usb 数组，如果是 Phone 变量，除了调用 Usb 接口声明的方法外，还需要调用 Phone 特有方法 call
   var computer Computer
   for _, v := range usbArr {
      computer.Working(v)
      fmt.Println()
   }
}

3 测试

手机开始工作。。。
手机 在打电话..
手机停止工作。。。
手机开始工作。。。
手机 在打电话..
手机停止工作。。。
相机开始工作。。。
相机停止工作。。。

二实战2

1 需求

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

2 代码

package main
import (
   "fmt"
)
// 定义 Student 类型
type Student struct {
}
// 编写一个函数，可以判断输入的参数是什么类型
func TypeJudge(items ...interface{}) {
   for index, x := range items {
      switch x.(type) {
      case bool:
         fmt.Printf("第%v个参数是 bool 类型，值是%v\n", index, x)
      case float32:
         fmt.Printf("第%v个参数是 float32 类型，值是%v\n", index, x)
      case float64:
         fmt.Printf("第%v个参数是 float64 类型，值是%v\n", index, x)
      case int, int32, int64:
         fmt.Printf("第%v个参数是 整数 类型，值是%v\n", index, x)
      case string:
         fmt.Printf("第%v个参数是 string 类型，值是%v\n", index, x)
      case Student:
         fmt.Printf("第%v个参数是 Student 类型，值是%v\n", index, x)
      case *Student:
         fmt.Printf("第%v个参数是 *Student 类型，值是%v\n", index, x)
      default:
         fmt.Printf("第%v个参数是  类型 不确定，值是%v\n", index, x)
      }
   }
}
func main() {
   var n1 float32 = 1.1
   var n2 float64 = 2.3
   var n3 int32 = 30
   var name string = "tom"
   address := "北京"
   n4 := 300
   stu1 := Student{}
   stu2 := &Student{}
   TypeJudge(n1, n2, n3, name, address, n4, stu1, stu2)
}

3 测试

第0个参数是 float32 类型，值是1.1
第1个参数是 float64 类型，值是2.3
第2个参数是 整数 类型，值是30
第3个参数是 string 类型，值是tom
第4个参数是 string 类型，值是北京
第5个参数是 整数 类型，值是300
第6个参数是 Student 类型，值是{}
第7个参数是 *Student 类型，值是&{}