GO学习笔记09

接口

1.接口定义

    package main
    
    import "fmt"
    
    //定义接口类型
    type Humaner interface {
        sayHi()
    }
    
    type Student struct {
        name string
        id   int
    }
    
    func (stu *Student) sayHi() {
        fmt.Printf("Student[%s,%d] sayHi\n", stu.name, stu.id)
    }
    
    type Teacher struct {
        addr  string
        group string
    }
    
    func (teacher *Teacher) sayHi() {
        fmt.Printf("Teacher[%s,%s] sayHi\n", teacher.addr, teacher.group)
    }
    
    type Mystr string
    
    func (str *Mystr) sayHi() {
        fmt.Printf("Mystr[%s] sayHi\n", *str)
    }
    
    func main() {
        var human Humaner
        s := &Student{"tony", 77}
        human = s
        human.sayHi()
    
        t := &Teacher{"tom", "go"}
        human = t
        human.sayHi()
    
        var str Mystr = "Hello Tony"
        human = &str
        human.sayHi()
    }
    
    
    Student[tony,77] sayHi
    Teacher[tom,go] sayHi
    Mystr[Hello Tony] sayHi

2.多态

    package main
    
    import "fmt"
    
    //定义接口类型
    type Humaner interface {
        sayHi()
    }
    
    type Student struct {
        name string
        id   int
    }
    
    func (stu *Student) sayHi() {
        fmt.Printf("Student[%s,%d] sayHi\n", stu.name, stu.id)
    }
    
    type Teacher struct {
        addr  string
        group string
    }
    
    func (teacher *Teacher) sayHi() {
        fmt.Printf("Teacher[%s,%s] sayHi\n", teacher.addr, teacher.group)
    }
    
    type Mystr string
    
    func (str *Mystr) sayHi() {
        fmt.Printf("Mystr[%s] sayHi\n", *str)
    }
    
    //定义一个普通函数，函数的参数为接口类型
    //只有一个函数，可以有不同的表现，多态
    func WhoSayHi(humaner Humaner) {
        humaner.sayHi()
    }
    
    func main() {
        s := &Student{"tony", 77}
        t := &Teacher{"tom", "go"}
        var str Mystr = "Hello Tony"
    
        //调用同一个函数，不同的表现
        WhoSayHi(s)
        WhoSayHi(t)
        WhoSayHi(&str)
    
        //创建一个切片
        x := make([]Humaner, 3)
        x[0] = s
        x[1] = t
        x[2] = &str
    
        fmt.Println("------------------------")
        //第一个返回下标，第二个返回下标所对应的值
        for _, i := range x {
            i.sayHi()
        }
    
    }
    
    Student[tony,77] sayHi
    Teacher[tom,go] sayHi
    Mystr[Hello Tony] sayHi
    ------------------------
    Student[tony,77] sayHi
    Teacher[tom,go] sayHi
    Mystr[Hello Tony] sayHi

3.接口的继承

 package main
    
    import "fmt"
    
    //定义接口类型
    type Humaner interface {        //子集
        sayHi()
    }
    
    type Personer interface {       //超集
        Humaner //匿名字段，继承sayHi()
        sing(lrc string)
    }
    
    type Student struct {
        name string
        id   int
    }
    
    //Student实现了sayHi
    func (stu *Student) sayHi() {
        fmt.Printf("Student[%s,%d] sayHi\n", stu.name, stu.id)
    }
    
    func (tmp *Student) sing(lrc string) {
        fmt.Println("Student在唱着：", lrc)
    }
    
    func main() {
        var i Personer
        s := &Student{"Tony", 66}
        i = s
    
        i.sayHi()
        i.sing("好汉歌")
    }
    
    
    Student[Tony,66] sayHi
    Student在唱着： 好汉歌

4.接口转换

    package main
    
    import "fmt"
    
    //定义接口类型
    type Humaner interface {
        sayHi()
    }
    
    type Personer interface {
        Humaner //匿名字段，继承sayHi()
        sing(lrc string)
    }
    
    type Student struct {
        name string
        id   int
    }
    
    //Student实现了sayHi
    func (stu *Student) sayHi() {
        fmt.Printf("Student[%s,%d] sayHi\n", stu.name, stu.id)
    }
    
    func (tmp *Student) sing(lrc string) {
        fmt.Println("Student在唱着：", lrc)
    }
    
    func main() {
        //超集可以转换成子集，反过来不可以
        var iPro Personer
        iPro = &Student{"mike", 777}
    
        var i Humaner
    
        //iPro = i //err
        i = iPro
        i.sayHi()
    
    }
    
    
    Student[mike,777] sayHi

5.空接口

    package main
    
    import "fmt"
    
    //定义这样的方法可以
    func xxx(arg ...interface{}) {
    
    }
    
    func main() {
        //空接口万能类型，保存任意类型的值
        var i interface{} = 1
        fmt.Println("i = ", i)
    
        i = "abc"
        fmt.Println("i = ", i)
    
    }
    
    
    i =  1
    i =  abc

6.类型判断之断言

    package main
    
    import "fmt"
    
    type Cat struct {
        name string
        id   int
    }
    
    func main() {
        i := make([]interface{}, 3)
        i[0] = 1
        i[1] = "hello go"
        i[2] = Cat{"tom", 3}
    
        for index, data := range i {
            if value, ok := data.(int); ok == true {
                fmt.Printf("x[%d] 类型为int,内容为%d\n", index, value)
            } else if value, ok := data.(string); ok == true {
                fmt.Printf("x[%d] 类型为string,内容为%s\n", index, value)
            } else if value, ok := data.(Cat); ok == true {
                fmt.Printf("x[%d] 类型为Cat,name = %s,id =%d\n ", index, value.name, value.id)
            }
        }
    
    }
    
    
    x[0] 类型为int,内容为1
    x[1] 类型为string,内容为hello go
    x[2] 类型为Cat,name = tom,id =3

7.类型判断之switch

    package main
    
    import "fmt"
    
    type Cat struct {
        name string
        id   int
    }
    
    func main() {
        i := make([]interface{}, 3)
        i[0] = 1
        i[1] = "hello go"
        i[2] = Cat{"tom", 3}
    
        for index, data := range i {
            switch value:=data.(type) {
            case int:
                fmt.Printf("x[%d] 类型为int,内容为%d\n", index, value)
            case string:
                fmt.Printf("x[%d] 类型为string,内容为%s\n", index, value)
            case Cat:
                fmt.Printf("x[%d] 类型为Cat,name = %s,id =%d\n ", index, value.name, value.id)
            }
        }
    }
    
    
    x[0] 类型为int,内容为1
    x[1] 类型为string,内容为hello go
    x[2] 类型为Cat,name = tom,id =3