Go 接口嵌套与组合

假设我们定义了表示小狗的 Dog 结构体和表示小猫的 Cat 结构体,并各自绑定了同名的 Speak() 方法。现在如果想要编写一个通用函数,既能接收 Dog 又能接收 Cat,函数的参数类型应该怎么写呢?写 Dog 就传不了 Cat,写 Cat 又传不了 Dog。

为了解决这类问题,Go 语言提供了 “接口(interface)”。接口就像电脑上的 USB 插口,它不关心插上来的是鼠标、键盘还是 U 盘,只要插头符合 USB 标准就能正常工作。换句话说,接口不关心具体是什么结构体,只规定它必须具备哪些方法。

Go 接口就像统一标准的 USB 插口

Go 接口的定义与实现

在 Go 语言中,结构体与接口的分工非常明确,主要有以下 2 点区别:

  • 结构体(struct):用来保存具体的 “数据字段”,表示一个对象 “有什么”,比如小狗有名字和年龄。
  • 接口(interface):用来规定统一的 “方法清单”,表示一个对象 “能做什么”,比如能叫、能跑、能付款。

我们可以使用 type 和 interface 关键字来定义一个接口。其中,interface 在英文中就是 “接口” 的意思。

语法:

type 接口名 interface {
    方法名1(参数列表) 返回值类型
    方法名2(参数列表) 返回值类型
}

说明:

接口的花括号({})内部只写方法的名称、参数和返回值类型,不写具体的函数体。也就是说,接口只负责列出 “方法清单”,至于每个方法具体怎么执行,则交给后面的结构体去实现。

在接口的方法参数列表中,参数名是可以省略的,写成 Pay(int) 或 Pay(amount int) 都合法。不过在实际开发中,我们更推荐写上参数名,方便一眼看清每个参数的含义。

与其他编程语言(如 Java)不同,Go 语言的接口采用的是 “隐式实现”。我们不需要使用专门的关键字去声明某个结构体实现了哪个接口。只要一个结构体把接口里列出的全部方法都实现了,Go 编译器就会自动认为它实现了这个接口。

示例 1:定义并实现接口

package main

import "fmt"

// 定义接口
type Speaker interface {
    Speak() string
}

type Dog struct {
    Name string
}

// Dog 实现 Speak() 方法
func (d Dog) Speak() string {
    return d.Name + ":汪汪汪"
}

type Cat struct {
    Name string
}

// Cat 实现 Speak() 方法
func (c Cat) Speak() string {
    return c.Name + ":喵喵喵"
}

func main() {
    var s Speaker

    s = Dog{Name: "旺财"}
    fmt.Println(s.Speak())

    s = Cat{Name: "咪咪"}
    fmt.Println(s.Speak())
}

运行结果如下。

旺财:汪汪汪
咪咪:喵喵喵

分析:

上面这个例子定义了一个 Speaker 接口,要求实现返回值为 string 类型的 Speak() 方法。观察 Dog 和 Cat 的代码可以发现,它们内部完全没有提到 Speaker,但因为都实现了 Speak() string 方法,所以自动实现了该接口。

var s Speaker 这句代码表示声明了一个接口类型的变量 s。在 Go 语言内部,一个接口变量就像自带类型标签的格子,同时记录着两样东西:当前存入的具体值,以及这个值的具体类型。

正因如此,当我们先后把 Dog 和 Cat 赋给 s 时,调用 s.Speak() 才能准确执行各自对应的方法。

单看上面这几行代码,直接通过结构体变量调用 Speak() 也能得到同样的结果。这里主要是帮小伙伴们熟悉接口变量的赋值写法,下面我们再来看看接口在实际开发中的两种常见用法。

提示: 在 Go 语言中,如果一个接口只包含一个方法,按照约定俗成的命名习惯,通常会在方法名后面加上 “-er” 后缀作为接口名。比如包含 Speak() 方法的接口命名为 Speaker,包含 Read() 方法的接口命名为 Reader。

接口的常见用法

回到文章开头的问题:怎样编写一个既能接收 Dog 又能接收 Cat 的通用函数呢?答案就是把函数的参数类型定义为接口类型。只要把参数写成接口,任何实现了该接口的结构体都能作为实参传进去,并在函数内部自动执行各自对应的方法。

在实际开发中,这种写法用得非常广泛。比如开发商城的结账功能时,不管是微信支付还是支付宝支付,只要它们实现了统一的支付接口,就可以共用同一个结账函数。下面我们来看具体的实现代码。

示例 2:将接口作为函数参数

package main

import "fmt"

// 定义支付接口
type Payer interface {
    Pay(amount int)
}

type WeChat struct{}

func (w WeChat) Pay(amount int) {
    fmt.Printf("使用微信支付了 %d 元\n", amount)
}

type Alipay struct{}

func (a Alipay) Pay(amount int) {
    fmt.Printf("使用支付宝支付了 %d 元\n", amount)
}

// 接收 Payer 接口作为参数
func checkout(p Payer, money int) {
    p.Pay(money)
}

func main() {
    wx := WeChat{}
    ali := Alipay{}

    checkout(wx, 50)
    checkout(ali, 100)
}

运行结果如下。

使用微信支付了 50 元
使用支付宝支付了 100 元

分析:

type WeChat struct{} 表示定义一个不包含任何字段的空结构体。因为这里我们只需要调用它的 Pay() 方法,不需要在结构体内部保存额外的数据。

函数 checkout(p Payer, money int) 的第 1 个参数类型是 Payer 接口。当我们第 1 次调用并传入 wx 时,p.Pay(money) 执行的是 WeChat 的支付方法。当我们第 2 次调用并传入 ali 时,执行的则是 Alipay 的支付方法。

这种写法在扩展新功能时非常省事。假如以后商城要新增一种 “银行卡支付”,我们只需要新定义一个 Card 结构体并实现 Pay(amount int) 方法,就能直接传给 checkout() 函数使用,原有的结账代码一行都不用改。

除了作为函数参数之外,接口还经常用来定义切片。普通的 []Dog 切片只能装小狗,但如果把元素类型写成接口,我们就能把不同的结构体放进同一个切片里统一遍历。下面来看一个例子。

示例 3:使用接口切片统一处理

package main

import "fmt"

type Speaker interface {
    Speak() string
}

type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return d.Name + ":汪汪汪"
}

type Cat struct {
    Name string
}

func (c Cat) Speak() string {
    return c.Name + ":喵喵喵"
}

func main() {
    // 使用 Speaker 接口切片存放不同的结构体
    animals := []Speaker{
        Dog{Name: "旺财"},
        Cat{Name: "咪咪"},
    }

    for _, a := range animals {
        fmt.Println(a.Speak())
    }
}

运行结果如下。

旺财:汪汪汪
咪咪:喵喵喵

分析:

[]Speaker 表示一个元素类型为 Speaker 接口的切片。只要实现了 Speaker 接口的结构体,都可以直接放进这个切片里。通过 for range 遍历时,每次调用 a.Speak() 都会自动执行当前元素的具体方法。

此外,接口和结构体之间并不是 “一对一” 的绑定关系。一个接口可以被多个结构体实现,而同一个结构体也可以同时实现多个不同的接口。比如 Dog 除了实现 Speaker 接口之外,只要再实现一个 Run() 方法,就能同时满足另一个 Runner 接口的要求。

“值接收者” 与 “指针接收者” 实现接口的区别

在 Go 语言中,结构体的方法分为值接收者与指针接收者两种。当我们使用这两种不同的接收者去实现接口时,赋值给接口变量的规则有着明显的区别:

  • 使用值接收者实现接口:我们既可以把结构体值(如 Dog{})赋值给接口变量,也可以把结构体指针(如 &Dog{})赋值给接口变量。
  • 使用指针接收者实现接口:我们只能把结构体指针(如 &Dog{})赋值给接口变量,如果直接传入结构体值就会触发编译报错。

很多初学的小伙伴在编写指针接收者方法时,经常因为漏写了取地址符(&)而遇到报错。下面我们通过一个修改车速的例子来看看具体是怎么回事。

示例 4:指针接收者实现接口

package main

import "fmt"

type Mover interface {
    SpeedUp()
}

type Car struct {
    Brand string
    Speed int
}

// 使用指针接收者修改车速
func (c *Car) SpeedUp() {
    c.Speed += 20
    fmt.Printf("%s加速后车速:%d\n", c.Brand, c.Speed)
}

func main() {
    car := Car{Brand: "宝马", Speed: 60}

    var m Mover
    m = &car    // 传入结构体指针
    m.SpeedUp()

    fmt.Printf("当前实际车速:%d\n", car.Speed)
}

运行结果如下。

宝马加速后车速:80
当前实际车速:80

分析:

可能有些小伙伴会觉得奇怪:“前面学习结构体方法时,普通变量 car 也能直接调用指针接收者的方法,为什么赋给接口变量 m 时就必须加上 & 呢?”

其实原因很简单。SpeedUp() 使用的是指针接收者 *Car,内部执行了 c.Speed += 20 来修改原结构体的车速。如果我们把结构体值 car 直接赋给接口变量 m,接口内部保存的就只是一份复制出来的副本。

一旦通过接口 m 去修改这份副本的车速,外面的原变量 car 根本不会发生改变。为了避免这种隐蔽的逻辑错误,Go 编译器直接规定:使用指针接收者实现的方法只属于指针类型 *Car,给接口变量赋值时必须传入结构体指针。

car := Car{Brand: "宝马", Speed: 60}
var m Mover

// 正确方式
m = &car

// 错误方式
m = car

反过来,如果像示例 1 那样使用值接收者定义方法,情况就宽松多了。因为值接收者方法本来就不会修改原结构体,所以无论传入结构体值 Dog{} 还是结构体指针 &Dog{} 都是合法的。

注意: 在实际开发中,如果结构体的某个方法使用了指针接收者,建议把该结构体的其他方法也统一写成指针接收者。需要把该结构体赋值给接口变量或传给接口参数时,记得统一传入结构体指针(如 &car),这样既能省去拷贝大结构体的开销,又不会触发类型报错。

使用接口的注意事项

在日常编写接口代码时,还有两个初学者容易踩坑的细节需要注意:一是必须实现接口规定的全部方法,二是不要对未初始化的 nil 接口直接调用方法。

1. 必须实现接口的全部方法

一个接口中可以包含一个方法,也可以同时包含多个方法。当接口包含多个方法时,结构体必须把接口里列出的所有方法全部实现,才算实现了该接口。如果漏掉了其中任何一个方法,或者方法的参数、返回值类型不一致,编译时都会直接报错。

示例 5:漏实现接口方法

package main

import "fmt"

type Machine interface {
    Start()
    Stop()
}

type Fan struct{}

// 只实现了 Start(),漏掉了 Stop()
func (f Fan) Start() {
    fmt.Println("风扇启动")
}

func main() {
    var m Machine
    m = Fan{}
    m.Start()
}

运行结果如下。

(报错)cannot use Fan{} (value of type Fan) as Machine value in assignment: Fan does not implement Machine (missing method Stop)

分析:

从运行结果可以看出,编译时直接报错并提示 “missing method Stop”,意思是缺少 Stop() 方法。这是因为 Machine 接口规定了 Start() 和 Stop() 两个方法,而 Fan 结构体只实现了其中一个,因此不能赋值给接口变量 m。

2. 未初始化的 nil 接口

如果我们只声明了一个接口变量,还没有给它赋任何具体的结构体值,那么它内部既没有具体类型也没有具体值,默认零值就是 nil。

示例 6:未初始化的 nil 接口

package main

import "fmt"

type Speaker interface {
    Speak() string
}

func main() {
    var s Speaker
    fmt.Println(s)
    fmt.Println(s == nil)
}

运行结果如下。

<nil>
true

分析:

var s Speaker 只声明了接口变量 s,没有赋具体的值,因此打印结果为 <nil>,s == nil 的判断结果为 true。

小伙伴们要特别注意,千万不要对一个值为 nil 的接口变量直接调用方法(比如直接写 s.Speak())。因为此时接口内部还没有绑定任何具体的结构体对象,运行时一旦调用就会直接报错崩溃。如果某个接口变量可能为空,调用方法前记得先用 if s != nil 做一下判断。

隐式接口与 “鸭子类型”

为什么 Go 语言不需要像 Java 或 C# 那样,使用 implements 关键字来显式声明实现某个接口呢?

其实这是 Go 语言非常经典的设计,在编程界通常称为 “鸭子类型(Duck Typing)”。它有一句很形象的俗语:“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子。”

采用隐式实现最大的好处,就是让结构体和接口之间不需要提前绑定。哪怕是别人写好的第三方包里的结构体,只要它的方法恰好符合我们定义的接口要求,就能直接当成这个接口来使用,完全不用去修改别人原本的代码。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号