1.把接口转为结构体，再塞给一个结构体的变量
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)
fmt.Println(b)
//类型断言的其他案例
var x interface{}
var b2 float32 = 1.1
x = b2 //变量塞给空接口，可以【类型推断】
y, ok := x.(float64)
if ok == true {
fmt.Println("convert success")
fmt.Printf("y的类型是%T 值是=%v", y, y)
} else {
fmt.Println("convert fail")
}
fmt.Println("继续胡扯")
}
Go
复制代码
{1 2}
convert fail
继续胡扯
2.接口体现多态：多态参数
Go
复制代码
package main
//接口，接口体现多态：多态参数
import "fmt"
// interface不能包含任何变量
type Usb interface {
start()
stop()
}
// 手机实现User方法
type Phone struct {
name string
}
func (p Phone) start() {
fmt.Println("手机开始工作")
}
func (p Phone) stop() {
fmt.Println("手机停止工作")
}
func (p Phone) Call() {
fmt.Println("手机再打电话...")
}
type Camera struct {
name string
}
func (c Camera) start() {
fmt.Println("摄像机开始工作")
}
func (c Camera) stop() {
fmt.Println("摄像机停止工作")
}
// 计算机
type Computer struct {
}
// Working方法，接受一个User接口的类型变量
func (c Computer) Working(usb Usb) {
//通过接口变量来调用start，stop方法
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{"oppo"}
usbArr[1] = Phone{"vivo"}
usbArr[2] = Camera{"索尼"}
fmt.Println(usbArr)
var computer Computer
for _, v := range usbArr {
computer.Working(v)
}
}
Go
复制代码
手机停止工作
手机开始工作
手机再打电话...
手机停止工作
摄像机开始工作
摄像机停止工作
3.编写一个函数，可以判断输入的参数是什么类型
Go
复制代码
package main
import "fmt"
//编写一个函数，可以判断输入的参数是什么类型
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个参数是int类型，值是%v\n", index, x)
case string:
fmt.Printf("第%v个参数是string类型，值是%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 := 3000
TypeJudge(n1, n2, n3, name, address, n4)
}
Go
复制代码
第0个参数是float32类型，值是1.1
第1个参数是float64类型，值是2.3
第2个参数是int类型，值是30
第3个参数是string类型，值是tom
第4个参数是string类型，值是北京
第5个参数是int类型，值是3000