go的interface的使用

阅读：3127 分享次数：0

package main
    
    import (
        "fmt"
    )
    
    //定义：Interface 是一组抽象方法(未具体实现的方法/仅包含方法名参数返回值的方法)的集合，有点像但又不同于其他编程语言中的 interface 。type interfaceName interface {//方法列表}  
    //注意：1：interface 可以被任意对象实现，一个类型/对象也可以实现多个 interface，2：方法不能重载，如 eat() eat(s string) 不能同时存在  
    //值：声明为 interface 类型的变量，可以存储任何实现了 interface 中所有方法的类型的变量(对象)。类的值类型传递方法会自动生成对应的引用类型传递方法，反之不成立  
    //组合：将一个 interface1 嵌入到另一个 interface2 的声明中。其作用相当于把 interface1 的函数包含到 interface2 中，但是组合中不同有重复的方法。1.只要两个接口中的方法列表相同(与顺序无关)，即为相同的接口，可以相互赋值。2. interface1 的方法列表属于另一个 interface2 的方法列表的子集，interface2 可以赋值给 interface1，反之不成立(因为方法缺失)，interface2 中的方法会覆盖 interface1 中同名的方法。3.可以嵌入包中的 interface
      
    type person struct {  
        name string  
        age  int  
    }
    
    func (p person) printMsg() {  
        fmt.Printf("I am %s, and my age is %d.\n", p.name, p.age)  
    }
    
    func (p person) eat(s string) {  
        fmt.Printf("%s is eating %s ...\n", p.name, s)  
    }
    
    func (p person) drink(s string) {  
        fmt.Printf("%s is drinking %s ...\n", p.name, s)  
    }
    
    type people interface {  
        printMsg()  
        peopleEat //组合  
        peopleDrink  
        //eat() //不能出现重复的方法  
    }  
    
    /**
    //与上面等价
    type people interface {  
        printMsg()  
        eat()  
        drink()  
    }
    */
    
    type peopleDrink interface {  
        drink(s string)  
    }
    
    type peopleEat interface {  
        eat(s string)  
    }
    
    type peopleEatDrink interface {  
        eat(s string)  
        drink(s string)  
    }
    
    //以上 person 类[型]就实现了 people/peopleDrink/peopleEat/peopleEatDrink interface 类型
    
    type foodie struct {  
        name string  
    }
    
    func (f foodie) eat(s string) {  
        fmt.Printf("I am foodie, %s. My favorite food is the %s.\n", f.name, s)  
    }
    
    //foodie 类实现了 peopleEat interface 类型
    
    func echoArray(a interface{}) {  
        b, _ := a.([]int) //这里是断言实现类型转换,如何不使用就会报错  
        for _, v := range b {  
            fmt.Println(v, " ")  
        }  
        return  
    }
    
    //任何类型都可以是interface
    //要点：1interface关键字用来定义一个接口,2.Go没有implements、extends等关键字，3.实现一个接口的方法就是直接定义接口中的方法4.要实现多态，就要用指针或&object语法
    
    func main() {  
        //定义一个people interface类型的变量p1
        var p1 people  
        p1 = person{"zhuihui", 40}  
        p1.printMsg()  
        p1.drink("orange juice")  
    
        //同一类可以属于多个 interface, 只要这个类实现了这个 interface中的方法
        var p2 peopleEat
        p2 = person{"zengzhihai", 40}
        p2.eat("bread")
    
        //不同类也可以实现同一个 interface
        var p3 peopleEat
        p3 = foodie{"ceshi"}
        p3.eat("noodle")
    
        //interface赋值
        p3 = p1 //p3中的方法会被p1中覆盖
        p3.eat("noodle")
    
        //interface查询
        //将子集peopleEat 转成people类型
        if p4, ok := p2.(people); ok {
            p4.drink("water")
            fmt.Println(p4)
        }
    
        //interface{}使得我们可以向函数传递任意类型的变量；
        //断言解决在使用interface{}的情况下，空接口类型向普通类型转换的类型转换问题；
        //普通类型之间的转换最好使用显式的类型转换，否者很可能导致严重的错误。
        a := []int{3, 5, 6}
        echoArray(a)
    
    }
	
    //空接口，无方法，即 interface{}，可以代表任何类型，有点类似于 java 中的 Object 类可以作为任何形参和返回类型，mixed

感觉本站内容不错，读后有收获？

我要小额打赏，鼓励作者写出更好的教程

扫码关注公众号：talk_lizhi