Go语言学习之旅--接口

Posted 2022-11-20 赵jc

接口

• 接口
• 实现接口必须实现接口中的所有方法
• golang接口值类型接收者和指针类型接收者
• golang接口和类型的关系
• 一个类型实现多个接口
• 多个类型实现同一个接口
• golang接口嵌套

接口

go语言的接口，是一种新的类型定义，它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。

• 语法格式

/* 定义接口 */
type interface_name interface 
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]


/* 定义结构体 */
type struct_name struct 
   /* variables */


/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] 
   /* 方法实现 */

...
func (struct_name_variable struct_name) method_namen() [return_type] 
   /* 方法实现*/

• 举例

下面我定义一个USB接口，有读read和写write两个方法，再定义一个电脑Computer和一个手机Mobile来实现这个接口。

USB接口

type USB interface 
    read()
    write()

Computer结构体

type Computer struct 

Mobile结构体

type Mobile struct 

Computer实现USB接口方法

func (c Computer) read() 
    fmt.Println("computer read...")


func (c Computer) write() 
    fmt.Println("computer write...")

Mobile实现USB接口方法

func (c Mobile) read() 
    fmt.Println("mobile read...")


func (c Mobile) write() 
    fmt.Println("mobile write...")

测试

func main() 
    c := Computer
    m := Mobile

    c.read()
    c.write()
    m.read()
    m.write()

运行结果

func main() 
    c := Computer
    m := Mobile

    c.read()
    c.write()
    m.read()
    m.write()

实现接口必须实现接口中的所有方法

下面我们定义一个OpenClose接口，里面有两个方法open和close，定义个Door结构体，实现其中一个方法。

package main

import "fmt"

type OpenClose interface 
    open()
    close()


type Door struct 


func (d Door) open() 
    fmt.Println("open door...")


func main() 
    var oc OpenClose
    oc = Door // 这里编译错误，提示只实现了一个接口

golang接口值类型接收者和指针类型接收者

这个话题，本质上和方法的值类型接收者和指针类型接收者，的思考方法是一样的，值接收者是一个拷贝，是一个副本，而指针接收者，传递的是指针。
举例
定义一个Pet接口

type Pet interface 
    eat()

定义一个Dog结构体

type Dog struct 
    name string

实现Pet接口（接收者是值类型）

func (dog Dog) eat() 
    fmt.Printf("dog: %p\\n", &dog)
    fmt.Println("dog eat..")
    dog.name = "黑黑"

测试

func main() 
    dog := Dogname: "花花"
    fmt.Printf("dog: %p\\n", &dog)
    dog.eat()
    fmt.Printf("dog: %v\\n", dog)

运行结果

dog: 0xc000046240
dog: 0xc000046250
dog eat..
dog: 花花

从运行结果，我们看出dog的地址变了，说明是复制了一份，dog的name没有变说明，外面的dog变量没有被改变。

将Pet接口改为指针接收者

func (dog *Dog) eat() 
    fmt.Printf("dog: %p\\n", dog)
    fmt.Println("dog eat..")
    dog.name = "黑黑"

再测试

func main() 
    dog := &Dogname: "花花"
    fmt.Printf("dog: %p\\n", dog)
    dog.eat()
    fmt.Printf("dog: %v\\n", dog)

运行结果

dog: 0xc00008c230
dog: 0xc00008c230
dog eat..
dog: &黑黑

golang接口和类型的关系

1. 一个类型可以实现多个接口
2. 多个类型可以实现同一个接口（多态）

一个类型实现多个接口

一个类型实现多个接口，例如：有一个Player接口可以播放音乐，有一个Video接口可以播放视频，一个手机Mobile实现这两个接口，既可以播放音乐，又可以播放视频。
定义一个Player接口

type Player interface 
    playMusic()

定义一个Video接口

type Video interface 
    playVideo()

定义Mobile结构体

type Mobile struct 

实现两个接口

func (m Mobile) playMusic() 
    fmt.Println("播放音乐")


func (m Mobile) playVideo() 
    fmt.Println("播放视频")

测试

func main() 
    m := Mobile
    m.playMusic()
    m.playVideo()

运行结果

播放音乐
播放视频

多个类型实现同一个接口

比如，一个宠物接口Pet，猫类型Cat和狗类型Dog都可以实现该接口，都可以把猫和狗当宠物类型对待，这在其他语言中叫做多态。

定义一个Pet接口

type Pet interface 
    eat()

定义一个Dog结构体

type Dog struct 

定义一个Cat结构体

type Cat struct 

实现接口

func (cat Cat) eat() 
    fmt.Println("cat eat...")


func (dog Dog) eat() 
    fmt.Println("dog eat...")

测试

func main() 
    var p Pet
    p = Cat
    p.eat()
    p = Dog
    p.eat()

运行结果

cat eat...
dog eat...

golang接口嵌套

接口可以通过嵌套，创建新的接口。例如：飞鱼，既可以飞，又可以游泳。我们创建一个飞Fly接口，创建一个游泳接口Swim，飞鱼接口有这两个接口组成。

飞Flyer接口

type Flyer interface 
    fly()

创建Swimmer接口

type Swimmer interface 
    swim()

组合一个接口FlyFish

type FlyFish interface 
    Flyer
    Swimmer

创建一个结构体Fish

type Fish struct 

实现这个组合接口

func (fish Fish) fly() 
    fmt.Println("fly...")


func (fish Fish) swim() 
    fmt.Println("swim...")

测试

func main() 
    var ff FlyFish
    ff = Fish
    ff.fly()
    ff.swim()

运行结果

fly...
swim...