main.go

// Go语言·类型断言
package main

//  包的本质是创建不同的文件夹
//  go的每一个文件都是属于一个包的
//  go以包的形式管理项目和文件目录。
//  import "包的路径"
import (
    // model "day24/model"
    "fmt"
)

var content string = `
————————————————Go语言·类型断言————————————————————
一、类型断言 assert
    1.接口是一般类型，不知道具体类型，如果转成具体类型，就需要
    用类型断言
       在进行类型断言时，如果类型不匹配，就会报错panic，
    因此在进行类型断言时，要确保原来的空接口指向的就
    是断言的数据类型
        var x interface{}
        var b float32 = 1.1
        x = b //空接口，可以接受任意类型
        // x====>float32
        y := x.(float32) //x 空接口 必须是float32
        fmt.Printf("Y的类型：%T，值是%v",y,y)
    进行断言时，带上检测机制，成功就OK，失败不报panic
        // 带检测的类型断言
        var x interface{}
        var b float32 = 1.1
        x = b //空接口，可以接受任意类型
        // x====>float32
        // x 空接口必须是float32
        // y,ok := x.(float64) 
        if y,ok := x.(float64); ok {
            fmt.Printf("Y的类型：%T，值是%v",y,y)
        }else{
            fmt.Println("失败咯~~~")
        }
        fmt.Println("Continue...")
二、类型断言最佳实践：
    1.
        // 定义一个Usb接口数组，可以存放Phone和Camera结构体变量
        // 多态数组：
        pc     := model.Computer{}
        var usbArr [3]model.Usb
        usbArr[0] = model.Phone{"Iphone x max"}
        usbArr[1] = model.Phone{"小米"}
        usbArr[2] = model.Camera{"Sony"}
        for _,value := range usbArr {
            pc.Working(value)
            fmt.Println()
        }
    2.编写一个函数，可以判断输入的参数是什么类型
        类型断言：value.(type) 
        func TypeJudge(items ...interface{}) {...}

`

type Student struct {
    Name string
}


func TypeJudge(items ...interface{}) {
    for index ,value := range items {
        switch value.(type){
            case bool:
                fmt.Printf("第%v个参数是bool类型,值：%v \n",index,value)
            case float32:
                fmt.Printf("第%v个参数是float32类型,值：%v \n",index,value)
            case int,int8,int16,int32,int64:
                fmt.Printf("第%v个参数是整数类型,值：%v \n",index,value)
            case string:
                fmt.Printf("第%v个参数是string类型,值：%v \n",index,value)
            case Student:
                fmt.Printf("第%v个参数是Student类型,值：%v \n",index,value)
            case *Student:
                fmt.Printf("第%v个参数是*Student类型,值：%v \n",index,value)
            default:
                fmt.Printf("第%v个参数是类型不确定,值：%v \n",index,value)
        }
    }
}


func main() {
    var num1 float32 = 3.4
    var name string = "Lily"
    var num2 int = 100
    var stu1 = Student{
        Name:"Faker",
    }
     var stu2 = &Student{
        Name:"Uzi",
    }
    TypeJudge(num1,num2,name,stu1,stu2)
}

interface.go

package model

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

// working方法，接收一个Usb接口类型变量
// 实现Usb接口---》实现Usb接口声明的所有方法。
// usb接口变量，就体现多态-————多态参数
func (c Computer) Working(usb Usb) {
    // 通过usb接口变量来调用Start和Stop方法
    usb.Start()
    // 类型断言
    if phone,ok := usb.(Phone);ok {
        phone.Call()
    }
    usb.Stop()
}