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)		
		}
	}
}