【Go】十五、接口、多态、断言

爱被打了一巴掌 2024-04-23 15:44 155阅读 0赞

#### 文章目录 ####

*  1、接口的引入
 *  2、接口
 *  3、接口的注意点
 *  4、多态
 *  5、断言
 *  6、Type Switch

## 1、接口的引入 ##

以日常生活中打招呼为例，定义接口规范，各国人为打招呼为具体的实现

package main
    import "fmt"
    
    
    //接口的定义：定义规则、定义规范，定义某种能力：
    type SayHello interface{
        
            //声明没有实现的方法：
            sayHello()
    }
    
    =========================================分割线
    //接口的实现：定义一个结构体：
    //中国人：
    type Chinese struct{
        
    }
    //实现接口的方法---》具体的实现：
    func (person Chinese) sayHello(){
        
            fmt.Println("你好")
    }
    
    =========================================分割线
    
    //接口的实现：定义一个结构体：
    //美国人：
    type American struct{
        
    }
    //实现接口的方法---》具体的实现：
    func (person American) sayHello(){
        
            fmt.Println("hi")
    }
    
    =========================================分割线
    
    //定义一个函数：专门用来各国人打招呼的函数，接收具备SayHello接口的能力的变量：
    func greet(s SayHello){
        
            s.sayHello()
    }
    =========================================分割线
    
    //测试
    func main(){
        
            //创建一个中国人：
            c := Chinese{
        }
            //创建一个美国人：
            a := American{
        }
            //美国人打招呼：
            greet(a)
            //中国人打招呼：
            greet(c)
    }

## 2、接口 ##

*  接口中不能包含任何变量
 *  接口中定义一组方法，但不需要实现
 *  Go中没有implements关键字，实现接口要实现所有的方法才是实现，即Go的实现是基于方法的

## 3、接口的注意点 ##

1）接口本身不能创建实例，但是可以指向一个实现了该接口的自定义类型的变量

//直接用接口创建实例并调用方法，编译报错
    //var s SayHello
    //s.sayHello()
    c := Chinese{
        }
    var s SayHello = c
    s.sayHello()

2）只要是自定义数据类型，就可以实现接口，不仅仅是结构体类型

![在这里插入图片描述][15a20d98a796421cb487f97a47e639be.png]  
3）一个自定义类型可以实现多个接口

package main
    import "fmt"
    
    type AInterface interface{
        
            a()
    }
    
    type BInterface interface{
        
            b()
    }
    
    type Stu struct{
        
    }
    
    //实现接口A（的方法）
    func (s Stu) a(){
        
            fmt.Println("aaaa")
    }
    //实现接口B（的方法）
    func (s Stu) b(){
        
            fmt.Println("bbbb")
    }
    
    func main(){
        
            var s Stu
            var a AInterface = s		//注意这里的赋值
        	var b BInterface = s		//注意这里的赋值
            a.a()
            b.b()
    }

4）**一个接口(比如A接口)可以继承多个别的接口(比如B,C接口)**，这时如果要实现A接口,也必须将B,C接口的方法也全部实现

package main
    import "fmt"
    //C接口
    type CInterface interface{
        
            c()
    }
    
    //B接口
    type BInterface interface{
        
            b()
    }
    
    //A接口继承了B、C接口，且有自己的方法a()
    type AInterface interface{
        
            BInterface
            CInterface
            a()
    }
    
    //Stu结构体实现A接口，也要去实现B、C接口的方法
    type Stu struct{
        
    }
    
    func (s Stu) a(){
        
            fmt.Println("a")
    }
    func (s Stu) b(){
        
            fmt.Println("b")
    }
    func (s Stu) c(){
        
            fmt.Println("c")
    }
    func main(){
        
            var s Stu
            var a AInterface = s
            a.a()
            a.b()
            a.c()
    }

5）interface类型默认是一个指针(引用类型)，如果没有对interface初始化就使用,那么会输出nil

6）空接口没有任何方法,所以可以理解为所有类型都实现了空接口，也可以理解为我们**可以把任何一个变量赋给空接口**

![在这里插入图片描述][acd862ab59e2467d8f7eec526b12cc01.png]

注意上面两种空接口类型的写法，一种是自己定义一个：

type E interface{
        
    }
    
    Var e E = s

也可：

var e interface{
        } = s

## 4、多态 ##

面向对象的最后一个特征：多态，即多种形态，编译时、运行时两种状态。Go中的多态特征是通过接口实现的，可以按照统一的接口来调用不同的实现。如上面Part1中的SayHello，形参就是一个父类接口：

![在这里插入图片描述][c3140bd184854b599eeb623ddb81212e.png]

再比如定义SayHello数组，存放中国人结构体、美国人结构体

![在这里插入图片描述][449ddb5108f845d08f40021b5fa74cf0.png]

## 5、断言 ##

直接判断是否是该类型的变量，Java的instanceOf

value, ok := element.(T)

即，element是否为T类型，是转为T，值为value，且ok为true

package main
    import "fmt"
    //接口的定义：定义规则、定义规范，定义某种能力：
    type SayHello interface{
        
            //声明没有实现的方法：
            sayHello()
    }
    //接口的实现：定义一个结构体：
    //中国人：
    type Chinese struct{
        
            name string
    }
    //实现接口的方法---》具体的实现：
    func (person Chinese) sayHello(){
        
            fmt.Println("你好")
    }
    //中国人特有的方法
    func (person Chinese) niuYangGe(){
        
            fmt.Println("东北文化-扭秧歌")
    }
    //接口的实现：定义一个结构体：
    //美国人：
    type American struct{
        
            name string
    }
    //实现接口的方法---》具体的实现：
    func (person American) sayHello(){
        
            fmt.Println("hi")
    }
    //定义一个函数：专门用来各国人打招呼的函数，接收具备SayHello接口的能力的变量：
    func greet(s SayHello){
        
            s.sayHello()
            //断言：
            ch,flag := s.(Chinese)//看s是否能转成Chinese类型并且赋给ch变量,flag是判断是否转成功
            if flag == true{
        
                    ch.niuYangGe()
            }else{
        
                    fmt.Println("美国人不会扭秧歌")
            }
            fmt.Println("打招呼。。。")
    }
    func main(){
        
            
            //创建一个中国人：
            //c := Chinese{}
            //创建一个美国人：
            a := American{
        }
            //美国人打招呼：
            greet(a)
            //中国人打招呼：
            //greet(c)
    }

关键点：

![在这里插入图片描述][4b7ab0fd04774d97ae28f1a2a675d632.png]

## 6、Type Switch ##

一种特殊的switch语句，用type关键字。用法：

//定义一个函数：专门用来各国人打招呼的函数，接收具备SayHello接口的能力的变量：
    func greet(s SayHello){
        
            s.sayHello()
            switch s.(type){
        //type属于go中的一个关键字，固定写法
                    case Chinese:
                            ch := s.(Chinese)
                            ch.niuYangGe()
                    case American:
                            am := s.(American)
                            am.disco()
            }
            fmt.Println("打招呼。。。")
    }

完整示例：

package main
    import "fmt"
    //接口的定义：定义规则、定义规范，定义某种能力：
    type SayHello interface{
        
            //声明没有实现的方法：
            sayHello()
    }
    //接口的实现：定义一个结构体：
    //中国人：
    type Chinese struct{
        
            name string
    }
    //实现接口的方法---》具体的实现：
    func (person Chinese) sayHello(){
        
            fmt.Println("你好")
    }
    //中国人特有的方法
    func (person Chinese) niuYangGe(){
        
            fmt.Println("东北文化-扭秧歌")
    }
    //接口的实现：定义一个结构体：
    //美国人：
    type American struct{
        
            name string
    }
    //实现接口的方法---》具体的实现：
    func (person American) sayHello(){
        
            fmt.Println("hi")
    }
    func (person American) disco(){
        
            fmt.Println("野狼disco")
    }
    //定义一个函数：专门用来各国人打招呼的函数，接收具备SayHello接口的能力的变量：
    func greet(s SayHello){
        
            s.sayHello()
            switch s.(type){
        //type属于go中的一个关键字，固定写法
                    case Chinese:
                            ch := s.(Chinese)
                            ch.niuYangGe()
                    case American:
                            am := s.(American)
                            am.disco()
            }
            fmt.Println("打招呼。。。")
    }
    func main(){
        
            
            //创建一个中国人：
            c := Chinese{
        }
            //创建一个美国人：
            //a := American{}
            //美国人打招呼：
            //greet(a)
            //中国人打招呼：
            greet(c)
    }

[15a20d98a796421cb487f97a47e639be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/8c623b9b3c9d45719e12dd71bfdc6b96.png
[acd862ab59e2467d8f7eec526b12cc01.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/f024e965f0714f5b9da13a6364daa5dc.png
[c3140bd184854b599eeb623ddb81212e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/335d573fb245453faa56f8973ad04735.png
[449ddb5108f845d08f40021b5fa74cf0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/91551a97550c48d8aa13bd74d9fc254e.png
[4b7ab0fd04774d97ae28f1a2a675d632.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/7ae054b434a24b96862bc5fe12b9739f.png