GO 类型断言

package main

import(
	"fmt"
)
type Usb interface {
	Start()
	Stop()
}
type Phone struct{

}
func (p Phone) Start() {
	fmt.Println("手机开始工做")
}
func (p Phone) Stop() {
	fmt.Println("手机中止工做")
}
func (p Phone) Call() {
	fmt.Println("手机正在打电话")
}

type Cammera struct {

}
func (c Cammera) Start() {
	fmt.Println("相机开始工做")
}
func (c Cammera) Stop() {
	fmt.Println("相机中止工做")
}

type Computer struct {

}

//利用类型断言来区分usb是Phone 仍是 Commera
func (cp *Computer)Working(usb Usb) {
	usb.Start()
	if p,ok := usb.(Phone); ok == true {
		p.Call()
	}
	usb.Stop()
}

func main()  {
	var a interface{}
	var b float32 = 1.25
	a = b //b能够赋值给a
	var y float32 
	var z float64
	//y = a //这样不行
	y = a.(float32)//须要这样
	z, ok := a.(float64) //不是什么类型都能断言,须要看a的基础类型
	if ok == true {
		fmt.Printf("转换成成功%T,%v", z, z)
	} else {
		fmt.Println("转换失败")
	}
	fmt.Println(y)

	var usbArr [3]Usb
	usbArr[0] = Phone{}
	usbArr[1] = Cammera{}
	usbArr[2] = Phone{}

	var cp Computer
	for _,usb := range usbArr {
		cp.Working(usb)
		fmt.Println("---------------")
	}

	var n1 float32 = 1.2
	var n2 float64 = 1013.12313
	var n3 int = 33
	var n4 string = "afda"
	var n5 Phone = Phone{}
	var n6 *Phone = &Phone{}

	judeType(n1, n2, n3, n4, n5, n6)
}


func judeType(items ...interface{}) {
	for index,item := range items {
		switch item.(type) {
			case string:
				fmt.Printf("第%v个参数是string类型值为 %v\n", index, item)
			case float32:
				fmt.Printf("第%v个参数是float32类型值为 %v\n", index, item)
			case float64:
				fmt.Printf("第%v个参数是float64类型值为 %v\n", index, item)	
			case bool:
				fmt.Printf("第%v个参数是bool类型值为 %v\n", index, item)	
			case int,int32,int64:
				fmt.Printf("第%v个参数是int类型值为 %v\n", index, item)
			case Phone:
				fmt.Printf("第%v个参数是phone类型值为 %v\n", index, item)
			case *Phone:
				fmt.Printf("第%v个参数是*phone类型值为 %v\n", index, item)			
			default:
				fmt.Printf("第%v个参数是未知类型值为 %v\n", index, item)		
		}
	}
}