接口

接口

接口是一组函数的标签，接口中只有函数定义没有具体实现，需要某个类型为这个接口中的所有方法提供方法的实现，它被称为实现接口

当需要接口类型的对象时，可以使用任意实现类对象代替

接口对象不能访问实现类中的属性

多态：一个事务的多种形态，go语言提供接口模拟多态

就一个接口的实现：

​ 1.看成实现本身的类型，能够访问实现类中的属性和方法

​ 2.看成对应的接口类型，那就只能够访问接口中的方法**

接口的用法：(暂且没搞懂)

1.一个函数如果接受接口类型作为参数，那么实际上可以传入该接口的任意实现类对象作为参数。

2.定义一个类型为接口类型，实际上可以赋值为任意实现类的对象。

定义接口

type USB interface{
     
    start()//USB开始工作
    end()//USB结束工作
}

实现类

type Mouse struct{
     
    name string
}
type FlashDisk struct{
     
    name string
}
func (m Mouse)start(){
     
    fmt.Println(m.name,"鼠标开始工作")
}
func(m Mouse)end(){
     
    fmt.Println(m.name,"鼠标结束工作")
}
func (f FlashDisk)start(){
     
    fmt.Println(m.name,"键盘开始工作")
}
func(f FlashDisk)end(){
     
    fmt.Println(m.name,"键盘结束工作")
}

#####测试方法

func testInterface (usb USB){
     
    usb.start()
    usb.end()
}

func main(){
     
    m1:=Mouse{
     "罗技"}
    f1:=FlashDisk{
     "闪迪"}
    testInterface(m1)//鼠标开始工作  鼠标结束工作
    testInterface(f1)//键盘开始工作   键盘结束工作
    var usb USB
    usb=m1
    usb.start()//鼠标开始工作
    //usb.name无法访问
}

空接口

不包含任何的方法，所有的类型都实现了空接口，因此空接口可以存储任意类型的数值

type A interface{
     
    
}
type Cat struct.{
     
    color string
}
type Person struct{
     
    name string
    age int
}
//匿名空接口的使用
func test2(a interface{
     }){
     
    fmt.Println(a)
}
func main(){
     
    var a1 A=Cat{
     "花猫"}
    var a2 A=Person{
     "王二狗",30}
    var a3 A="haha"
    var a4 A=56
     fmt.Println(a1)//{花猫}
     fmt.Println(a2)//{王二狗 30}
     fmt.Println(a3)//haha
     fmt.Println(a4)//56
    test2(hehe)//hehe
}

空接口实现Map中的value为任意数据类型

map1:=make(map[string]interface{
     })
map1["namae"]="李小花"
map1["age"]=30
map1["friend"]=Person{
     "Jerry",18}
fmt.Println(map1)//map[age:30 friend:{Jerry 18} name:李小花]

实现切片中存储任意数据类型

slice1:=make([]interface{
     },0,10)
slice1=append(slice1,a1,a2,a3,a4,11,"aabc")
fmt.Println(slice1)//[{花猫} {王二狗 30} haha 56 100 abc]

接口断言

当一个函数的形参是interface{},那么在函数中，需要对形参进行断言，从而得到它的真实类型。

//安全类型断言
<目标类型的值>,<布尔参数>:=<表达式>.(目标类型)
instance,ok:=接口对象.(实际类型)
//非安全类型断言
<目标类型的值>:=<表达式>.(目标类型)
instance:=接口对象.(实际类型)//会panic

func getType(s Shape){
     
    //断言
    if ins,ok:=s.(Triangle);ok{
     
        fmt.Println("是三角形")
    }else if ins,ok:=s.(Circle);ok{
     
        fmt.Println("是圆形")
    }else{
     
        fmt.Println("不知道是什么类型")
    }
}
func getType2(s Shape){
     
    switch ins:=s.(type){
     
        case Triangle:
        fmt.Println("三角形",ins.a,ins.b,ins.c)
        case Circle:
        fmt.Println("圆形",ins.radius)
    }
}
type Shape interface{
     
    peri() float64//图形的周长
    area() float64//图形的面积
}
type Triangle struct{
     
    a,b,c float64
}
type Circle struct{
     
    radius float64
}