Go类型断言

package main
import (
	"fmt"
)
type Point struct {
	x int
	y int
}
func main() {
	var a interface{}
	var point Point = Point{1, 2}
	a = point  //oK
	// 如何将 a 赋给一个Point变量
	var b Point
	// b = a //不可以
	// b = a.(Point) //可以，类型断言
	b = a.(Point)
	fmt.Println(b) //{1 2}

	//类型断言的其它案例
	// var x interface{}
	// var b2 float32 = 1.1
	// x = b2  //空接口，可以接收任意类型
	// // x=>float32 [使用类型断言]
	// y := x.(float32) //这里必须是float32
	// fmt.Printf("y 的类型是 %T 值是=%v", y, y) //y 的类型是 float32 值是=1.1

	//类型断言(带检测的)
	var x interface{}
	var b2 float32 = 2.1
	x = b2  //空接口，可以接收任意类型
	// x=>float32 [使用类型断言]
	//类型断言(带检测的)
	if y, ok := x.(float32); ok { //golang支持在if中，直接定义一个变量
		fmt.Println("convert success") //convert success
		fmt.Printf("y 的类型是 %T 值是=%v", y, y) //y 的类型是 float32 值是=2.1继续执行...
	} else {
		fmt.Println("convert fail")
	}
	fmt.Println("继续执行...")

}

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("手机停止工作。。。")
}
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的结构体变量
	//这里就体现出多态数组
	//一个数组只能放一个数据类型，这里放了Phone类型，Camera类型
	var usbArr [3]Usb //数组存的是实现了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()
	}
	//fmt.Println(usbArr)
}

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)
	//第0个参数是 float32 类型，值是1.1
	//第1个参数是 float64 类型，值是2.3
	//第2个参数是 整数 类型，值是30
	//第3个参数是 string 类型，值是tom
	//第4个参数是 string 类型，值是北京
	//第5个参数是 整数 类型，值是300
	//第6个参数是 Student 类型，值是{}
	//第7个参数是 *Student 类型，值是&{}
}