Go 接口 Interface — 隐式实现、空接口与多态

接口(Interface)是 Go 实现多态的核心机制,也是它和 Java/C# 风格分道扬镳的地方。Go 的接口设计得极其轻巧:它只定义"能做什么"(方法签名),不关心"是谁"(具体类型),而且不需要显式声明实现关系。只要某个类型实现了接口要求的全部方法,它就自动满足这个接口——这种风格叫鸭子类型(duck typing),但和 Python 不同,Go 是在编译期完成检查的:类型不对根本编译不过,运行时也就不会突然报错。

一、接口的定义

定义接口用 type 名字 interface,后面跟一组方法签名。比如想抽象"会说话的东西",就定义一个 Speaker,它要求实现者必须有一个 Speak() string 方法。接口里只声明方法的名字、参数和返回值,不写实现。

package main

import "fmt"

// 接口定义:一组方法签名的集合
type Speaker interface {
    Speak() string
}

// Dog 实现了 Speaker(注意:没有写 implements,自动满足)
type Dog struct{ Name string }
func (d Dog) Speak() string { return "汪汪!我是 " + d.Name }

// Cat 也实现了 Speaker
type Cat struct{ Name string }
func (c Cat) Speak() string { return "喵~我是 " + c.Name }

func main() {
    // 接口变量可以装任何实现了它的具体类型
    pets := []Speaker{
        Dog{"旺财"},
        Cat{"咪咪"},
    }
    for _, p := range pets {
        fmt.Println(p.Speak())
    }
}
// 汪汪!我是 旺财
// 喵~我是 咪咪

注意 Dog 和 Cat 的定义里完全没出现 Speaker 这个词——没有 implements 关键字,也没有继承声明。但它们都实现了 Speak() string 方法,所以自动满足 Speaker 接口,可以直接放进 []Speaker 切片里统一调用。这就是 Go 接口的精髓。

二、隐式实现:鸭子类型

这种"实现了方法就算数"的机制,让 Go 的接口极其灵活。你可以先写一堆类型,再回头为它们抽象出一个接口,甚至接口和实现位于不同包、互不知情也能匹配。好处是解耦:函数参数声明成接口类型后,任何满足它的类型都能传进来,写测试时也方便用 mock 替换。Go 标准库很多接口(比如 io.Reader)只有一两个方法,正是为了让人轻松实现。

三、空接口 interface{} 与 any

如果不写任何方法,就得到空接口 interface{}——它对类型零要求,因此能装任何值:整数、字符串、切片、结构体都行。Go 1.18 之后给空接口起了个别名 any(两者完全等价),新代码推荐用更短的 any。空接口常用于"参数类型不确定"的场景,比如 fmt.Println 的参数就是 ...any。

四、类型断言与类型分支

空接口装值容易,取值就得告诉 Go"我以为它是啥"——这就是类型断言 x.(T)。推荐用带 ok 的双返回值形式 v, ok := x.(string),失败时 ok 为 false 而不会 panic;直接写 x.(string) 在类型不符时会 panic,慎用。如果分支情况很多,用类型分支(type switch)更清爽:switch t := v.(type) 会在每个 case 里把 t 自动推导成对应类型。

package main

import "fmt"

func main() {
    // 空接口 interface{}(Go 1.18+ 可写 any):能装任何类型
    var x any
    x = 42
    x = "hello"
    x = []int{1, 2, 3}

    // 类型断言 v, ok := x.(T):失败时 ok 为 false,不会 panic
    n, ok := x.(int)
    fmt.Println(n, ok)   // 0 false(x 现在是切片,不是 int)

    // 类型分支 switch x.(type):每个 case 里 t 自动是相应类型
    describe := func(v any) string {
        switch t := v.(type) {
        case int:
            return fmt.Sprintf("整数:%d", t)
        case string:
            return fmt.Sprintf("字符串:%q", t)
        case []int:
            return fmt.Sprintf("整型切片,长度 %d", len(t))
        default:
            return fmt.Sprintf("未知类型 %T", t)
        }
    }
    fmt.Println(describe(42))            // 整数:42
    fmt.Println(describe("hello"))       // 字符串:"hello"
    fmt.Println(describe([]int{1, 2}))   // 整型切片,长度 2
}

五、值接收者 vs 指针接收者

这是接口实现里最隐蔽的坑。如果方法用值接收者定义(如 func (c Cow) Sound()),那么值和指针都满足接口;如果用指针接收者定义(如 func (s *Sheep) Sound()),那么只有指针类型 *Sheep 满足接口,值类型 Sheep 不满足。原因很直观:值接收者的方法集对值和指针都可用,而指针接收者的方法集只在指针上。一旦混淆,编译器会直接报错,这也是 Go 编译期类型检查的好处。

package main

import "fmt"

// 演示值接收者 vs 指针接收者实现接口的差异
type Animal interface { Sound() string }

// Cow 用值接收者:值和指针都满足 Animal
type Cow struct{}
func (c Cow) Sound() string { return "moo" }

// Sheep 用指针接收者:只有 *Sheep 满足 Animal
type Sheep struct{}
func (s *Sheep) Sound() string { return "baa" }

func makeSound(a Animal) { fmt.Println(a.Sound()) }

func main() {
    c := Cow{}
    makeSound(c)        // ok:值接收者,值满足接口
    makeSound(&c)       // 也 ok:指针同样满足

    s := Sheep{}
    // makeSound(s)     // 编译错误:Sheep 没实现 Animal(只有 *Sheep 实现)
    makeSound(&s)       // ok:必须传指针
}

六、接口嵌套

接口可以组合——一个接口把多个接口"打包"在一起,要求实现方同时满足它们全部。标准库的 io.ReadWriter 就是 io.Reader 和 io.Writer 的组合。这种"小接口、可组合"的哲学是 Go 接口设计的精髓:接口越小、越聚焦,被实现和复用的概率就越高。

七、常见标准库接口

Go 标准库定义了一批高频接口,值得记住:

fmt.Stringer:实现 String() string 后,fmt.Println 打印该类型时自动调用,自定义"显示格式"。
error:实现 Error() string 即可当 error 用(下一篇详讲)。
io.Reader / io.Writer:Read([]byte) / Write([]byte),文件、网络、压缩流统统实现它,是流式处理的基础。
sort.Interface:实现 Len()、Less(i,j int)、Swap(i,j int) 后可用 sort.Sort 排序。

package main

import "fmt"

// fmt.Stringer 是标准库接口,定义 String() string
// 任何实现它的类型,被 fmt.Println 打印时都会自动调用 String()
type Money struct {
    Yuan int
    Jiao int
}

func (m Money) String() string {
    return fmt.Sprintf("¥%d.%d", m.Yuan, m.Jiao)
}

// 接口嵌套:把多个接口"打包"成一个新的、要求更全的接口
type Reader interface { Read(p []byte) (n int, err error) }
type Writer interface { Write(p []byte) (n int, err error) }
type ReadWriter interface {    // 同时要求 Read 和 Write
    Reader
    Writer
}

func main() {
    m := Money{Yuan: 12, Jiao: 5}
    fmt.Println(m)         // ¥12.5(自动调用 String())
    fmt.Printf("%v\n", m)  // 同上
}

小结

接口只定义"做什么",不关心"是谁";Go 用隐式实现让代码极解耦。
空接口 interface{}(即 any)能装任何值,配合类型断言/分支取出具体类型。
注意值/指针接收者对接口实现的差异:指针接收者只让指针满足接口。
多用小接口、靠嵌套组合,是地道 Go 风格。

上一篇 Go 方法与结构体 | 下一篇 Go 错误处理。

✈️💬