Go语言之接口(二十)

• 特性

  • 定义: 公共方法组合起来以封装特定功能的一个集合
  • 多态: 接口的多种实现方式
• 接口声明

• 如何实现接口

  目录结构

    ├── demo
    │    └── demo.go
    ├── go.mod
    ├── interface_demo
    │     └── interface_demo.go
    └── main.go

  定义接口intreface_demo.go文件

    package interface_demo
    
    type Behavior interface {  //定义接口
        Run() string           //定义方法
        Eat() string
    }

demo.go文件实现接口文件

        package demo
        import "fmt"
        type Animal struct {//父级结构体
            Colour string   //父级结构体属性
        }
        type Dog struct {   //Dog 结构体
            Animal          //Dog 结构体包含了Animal结构体的属性和方法
            ID int
            Name string
            Age int
        }
        type Cat struct {    //Cat 结构体
            Animal           //Cat 结构体包含了Animal结构体的属性和方法
            ID int
            Name string
            Age int
        }
        func (d *Dog)Run() string {//Dog结构体的Run方法(实现了interface_demo.go文件中的Run()方法)
            fmt.Println("ID:",d.ID,"DOG is running")
            return "DOG is running"
        }
        func (a *Animal)Eat() string {//Animal结构体的Run方法(实现了interface_demo.go文件中的Eat()方法)
            fmt.Println("yu yu yu yu")
            return "yu yu yu yu"
        }
        func (c *Cat)Run() string {//Cat结构体的Run方法(实现了interface_demo.go文件中的Run()方法)
            fmt.Println("ID:",c.ID,"Cat is running")
            return "Cat is running"
        }

main.go文件调用

    package main
    
    import (
        "./demo"
        "./interface_demo"
        "fmt"
    )
    func main()  {
        dog := new(demo.Dog)
        dog.ID = 1
        dog.Name = "dog"
        dog.Age = 5
        dog.Colour = "red"     //继承了Animal的属性
        dog.Eat()              //继承了Animal的方法       yu yu yu yu
        fmt.Println("\r")
        fmt.Println(dog)       //&{{red} 1 dog 5}
        fmt.Println("\r")
        //cat
        cat := new(demo.Cat)
        cat.ID = 2
        cat.Name = "cat"
        cat.Age = 6
        cat.Colour = "red11"   //继承了Animal的属性
        cat.Eat()              //继承了Animal的方法       yu yu yu yu
        fmt.Println("\r")
        fmt.Println(cat)       //&{{red11} 2 cat 6}
        fmt.Println("\r")
        //接口定义变量
        dog1 := new(demo.Dog) //赋值的时候创建一个结构体
        cat1 := new(demo.Cat) //赋值的时候创建一个结构体
        action(dog1)          //ID:1 Dog is running   调用的是Dog类的Run()方法
        action(cat1)          //ID:2 Cat is running   调用的是Cat类的Run()方法
    }
    
    func action(b interface_demo.Behavior)string  {//声明了一个接口
        b.Run()
        return ""
    }

**注意:**
只有同时实现了interface_demo.go文件中的Run()和Eat()方法,才会隐式实现接口interface_demo.go
声明了一个接口,赋值的时候创建一个结构体,则调用的方法是该结构体的方法