假设我们定义了表示小狗的 Dog 结构体和表示小猫的 Cat 结构体,并各自绑定了同名的 Speak() 方法。现在如果想要编写一个通用函数,既能接收 Dog 又能接收 Cat,函数的参数类型应该怎么写呢?写 Dog 就传不了 Cat,写 Cat 又传不了 Dog。
为了解决这类问题,Go 语言提供了 “接口(interface)”。接口就像电脑上的 USB 插口,它不关心插上来的是鼠标、键盘还是 U 盘,只要插头符合 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)”。它有一句很形象的俗语:“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子。”
采用隐式实现最大的好处,就是让结构体和接口之间不需要提前绑定。哪怕是别人写好的第三方包里的结构体,只要它的方法恰好符合我们定义的接口要求,就能直接当成这个接口来使用,完全不用去修改别人原本的代码。
