Go 语言的 interface 是其核心特性之一，它不仅简洁高效，还深刻影响了 Go 编程的设计哲学。本文将从 interface 的最初的设计构想入手，详细探讨 interface 的基本格式、空 interface 的特殊性质以及如何利用 interface 进行高阶编程。

1. Rob Pike 对 interface 的理解

Rob Pike，Go 语言的共同设计者之一，对 interface 的理解非常深入。他曾在多个场合强调，interface 的核心思想是 “隐式实现”。与其他编程语言中的 interface 不同，Go 语言中的 interface 不需要显式地声明某个类型实现了哪个 interface。只要一个类型实现了 interface 中定义的所有方法，它就隐式地实现了该 interface。这种设计让 interface 的使用变得更加灵活和简洁，同时减少了冗余的代码。

Rob Pike 在一个 Google Group 里面曾经评论道：

It's a hoary example to use geometry as an example of abstract computations, but there's an important detail here. It's always bothered me in OO languages that we can make Circle, Square, etc. subclasses of Shape (say), but that's the one design decision we get to make. What if we want to align those things along other axes (so to speak), like topological genus or plant genus, if you're a landscaper? You might lose your way or dig yourself into a hole with multiple inheritance.

In Go, that's a non-issue: Circle can satisfy independent interfaces for TopologicalGenus or GrassGenus as well as Area or Perimeter or Symmetry or whatever. Moreover, you don't have to work them all out ahead of time; the whole design can evolve without invalidating early decisions.

This point is critical to interfaces in Go, but people coming from an OO background don't seem to get it. By stopping at one interface for shapes, the author misses a chance to say something vital.

Go's interfaces aren't a variant on Java or C# interfaces, they're much more. They are a key to large-scale programming and adaptable, evolutionary design.

 

使用几何学作为抽象计算的例子可能看起来有些老生常谈，但这里有一个非常重要的细节。传统的面向对象语言中，如果我们需要定义 Circle、Square 等类的层次结构，它们通常会继承自一个共同的父类 Shape。然而，这种设计方式给我们带来的问题是，我们只能做一次设计决策：即如何将这些几何形状归为一类，按照某个特定的轴来进行分类。比如，你只能按照形状（Shape）这一属性来构建系统，而无法从其他维度来对这些几何形状进行分类。

那么，如果我们希望从不同的角度进行分类，例如从拓扑学上的“属”来考虑，或者从园艺学上的“植物属”来分类，这时传统的单一继承体系就显得不够灵活，甚至可能会导致设计陷入困境。特别是当你想从多个维度来对同一类事物进行建模时，传统的多重继承会让你面临代码重用和依赖管理等复杂问题，最终可能导致设计不清晰，维护困难。

然而，在 Go 中，这个问题不存在。Circle 可以同时实现多个 interface，比如 TopologicalGenus（拓扑学属）、GrassGenus（植物属）、Area（面积）、Perimeter（周长）、Symmetry（对称性）等等，而这些 interface 是独立的，不相互干扰。更重要的是，你不需要一开始就设计好所有的 interface；整个设计可以随着需求的发展而演进，而不必担心推翻早期的设计决策。

这点非常关键，它表明 Go 的 interface 设计远远超越了 Java 或 C# 中 interface 的概念。Go 的 interface 提供了高度的灵活性，使得程序能够在面对需求变化时迅速适应，而无需在早期就做出所有决策。Go 的 interface 不仅仅是用来描述方法的签名，更是构建大规模、可扩展系统的核心机制。它们让系统能够随着时间的推移不断演化和调整，而不被固定的设计模式所限制。

这段话的主要描述的就是“隐式 interface”的灵活性。至于如何理解这个观点，我们在后面会详细举例说明。首先我们来看看 interface 具体是个什么结构。

2. interface 的基本格式

Go 语言中，interface 的定义非常简单。其基本格式如下：

type InterfaceName interface {    Method1()    Method2()    // ...}

在 Go 中，interface 类型由一个或多个方法签名组成。任何类型只要实现了 interface 中的所有方法，就隐式地实现了该 interface。interface并不关心这些方法是如何实现的，只关心方法的签名。interface是一个抽象类型，你可以通过它来引用所有实现了这些方法的具体类型。这种“隐式实现”的方式使得 Go 的 interface 机制比传统的 interface 系统更加灵活，不需要显式地声明 interface的实现。

举个例子，假设我们有一个 Speaker interface，定义了一个 Speak() 方法：

type Speaker interface {    Speak() string}

任何类型，只要实现了 Speak() 方法，就被认为实现了 Speaker interface：

type Person struct {    Name string}

func (p Person) Speak() string {    return "Hello, my name is " + p.Name}

func main() {    var s Speaker = Person{Name: "John"}    fmt.Println(s.Speak())}

这里，Person 类型并没有显式声明实现了 Speaker interface，但由于它实现了 Speak() 方法，Go 语言自动认为 Person 类型实现了 Speaker interface。

多态

Go 语言的 interface 支持多态，但它的实现方式与传统面向对象语言（如 Java 或 C#）有所不同。Go 的多态主要体现在 interface 的动态绑定上。多个类型可以实现同一个 interface，而在运行时，interface 的具体实现会根据传入的类型而有所不同。

package main

import (    "fmt"    "math")

// 定义一个 Shape interfacetype Shape interface {    Area() float64}

// Circle 类型实现 Shape interfacetype Circle struct {    Radius float64}

func (c Circle) Area() float64 {    return math.Pi * c.Radius * c.Radius}

// Rectangle 类型实现 Shape interfacetype Rectangle struct {    Width, Height float64}

func (r Rectangle) Area() float64 {    return r.Width * r.Height}

// 打印 Shape 面积的函数，利用多态func printArea(s Shape) {    fmt.Println("Area:", s.Area())}

func main() {    // 创建不同的类型    circle := Circle{Radius: 5}    rectangle := Rectangle{Width: 4, Height: 6}

    // 使用同一个 interface 类型调用不同的实现，体现多态    printArea(circle)     // 调用 Circle 的 Area 方法    printArea(rectangle)  // 调用 Rectangle 的 Area 方法}

在这个例子中，printArea 函数的实现并不关心传入的是 Circle 还是 Rectangle 类型的对象。我们只需要知道它们实现了 Shape interface，具体的 Area 方法的调用是动态绑定的，取决于传入的具体类型。

1. 当我们传入 circle（一个 Circle 类型的对象）时，Area() 方法会调用 Circle 类型的实现，计算圆的面积。

2. 当我们传入 rectangle（一个 Rectangle 类型的对象）时，Area() 方法会调用 Rectangle 类型的实现，计算矩形的面积。

这就是 Go 中 interface 实现的多态，他跟 Java 的 interface 多态有相同的概念，也是允许不同类型的对象通过共同的 interface 类型进行统一的操作，而具体的实现则由传入的对象类型决定。

3. 隐式 interface 的优点

现在我们来聊一下该如何来理解 Rob Pike 的观点：“隐式 interface 仅仅是用来描述方法的签名，更是构建大规模、可扩展系统的核心机制。它们让系统能够随着时间的推移不断演化和调整，而不被固定的设计模式所限制。”

Go 语言的隐式 interface 是其与传统面向对象语言（如 Java、C#）interface 设计的一个显著区别。而仅仅是 interface 定义方式的改变就导致了系统设计上的思维方式的变化。下面我们将详细讲解隐式 interface 的优点，并通过具体例子来加深理解。

形式的区别

在 Go 中，interface 是隐式实现的。只要一个类型实现了 interface 的所有方法，Go 会自动认为该类型实现了该 interface。因此，你不需要显式地在类型中声明 interface 的实现，代码更简洁，灵活性更高。例子可以参考基本格式的例子

type Speaker interface {    Speak() string}

type Person struct {    Name string}

func (p Person) Speak() string {    return "Hello, my name is " + p.Name}

// Person 类型自动实现了 Speaker interface，无需显式声明

在 Java 中，interface 的实现必须显式声明。你需要在类中使用 implements 关键字来声明一个类实现了某个 interface，并且编译器会检查 interface 方法的实现。

interface Speaker {    String speak();}

class Person implements Speaker {    String name;

    @Override    public String speak() {        return "Hello, my name is " + name;    }}

对比总结

• 灵活性：Go 的隐式 interface 设计更灵活。因为你不需要显式声明实现关系，只要符合 interface 要求的类型就能自动“实现”interface，这有助于快速迭代和扩展。

• 清晰度：Java 的显式 interface 实现设计更清晰，特别是在大型项目中，interface 与实现之间的关系更加明确，易于追踪和维护。

• 代码量：Go 更简洁，因为不需要显式声明类型实现了某个 interface；而 Java 需要显式声明并实现 interface，代码较为冗长。笔者就真的见过在一个不算很大型的 Java 项目中，一个 Java 的类实现了多达 50 个 interface。interface 的名字满满的写了半个屏幕！

• 可扩展性：Go 在扩展功能时更加灵活，无需修改现有类型的声明，而 Java 在扩展时需要在类型中显式声明 interface 的实现。

interface 之道

鸭子模型

这是一个 Go 社区中被提及无数次的概念，即：

“如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子。”

换句话说，只要某个对象具备某些行为，就可以认为它是某个类型，即使它并没有显式地声明实现这个类型。所以我们也经常说一个 interface 只关心对象类型应该提供哪些功能，而不关心这些功能是如何实现的以及被谁实现的。这么理解还是很抽象，我们来举个例子，假设我们有一个系统需要提供“支付”功能。我们可以定义一个 interface 来描述支付行为：

// 定义支付 interfacetype Payment interface {    Pay(amount float64)}

在这个 interface 中，我们只关心一个行为——Pay，它的作用是完成支付，并不关心具体的支付方式如何实现。这就是行为的定义：定义了“支付”这个行为，它接受一个金额参数，并执行支付操作。

我们可以有多种不同的支付方式，每种支付方式的实现细节不同，但它们都实现了 Payment interface，满足同样的行为定义：

// 支付宝支付实现type Alipay struct{}

func (a Alipay) Pay(amount float64) {    fmt.Printf("Paying %.2f using Alipay\n", amount)}

// 微信支付实现type WeChatPay struct{}

func (w WeChatPay) Pay(amount float64) {    fmt.Printf("Paying %.2f using WeChat Pay\n", amount)}

而当程序去调用 Pay 这个方法时，会从表达式中推导出具体该使用哪一个实现了这个 interface 的类型。相比于 Java 在编译时检查 interface 是否使用正确，Go 只会在传递参数，返回参数，以及变量赋值时才会进行 interface 类型检查。

当你将一个类型作为 interface 类型的参数传递时，Go 会检查这个类型是否实现了该 interface。如果实现了 interface 的方法，Go 会自动认为该类型符合 interface 类型。

package main

import "fmt"

type Speaker interface {    speak()}

type Dog struct{}

func (d Dog) speak() {    fmt.Println("Woof!")}

type Person struct {    name string}

func (p Person) speak() {    fmt.Println("Hello, my name is", p.name)}

func introduce(speaker Speaker) {    speaker.speak()}

func main() {    dog := Dog{}    person := Person{name: "Alice"}    introduce(dog)     // 传递 Dog 类型，自动实现 Speaker interface    introduce(person)  // 传递 Person 类型，自动实现 Speaker interface}

Go 也会在返回值时检查类型是否实现了 interface。这意味着你可以返回实现了 interface 的类型，而不需要显式声明 interface 的实现。

package main

import "fmt"

type Speaker interface {    speak()}

type Dog struct{}

func (d Dog) speak() {    fmt.Println("Woof!")}

func getSpeaker() Speaker {    return Dog{}  // 返回一个实现了 Speaker interface 的类型}

func main() {    speaker := getSpeaker()  // 自动获取一个符合 Speaker interface 的类型    speaker.speak()}

Go 还会在类型赋值时检查是否可以将一个类型赋值给 interface 类型的变量。如果类型实现了 interface，赋值就会成功。

package main

import "fmt"

type Speaker interface {    speak()}

type Dog struct{}

func (d Dog) speak() {    fmt.Println("Woof!")}

func main() {    var speaker Speaker    dog := Dog{}    speaker = dog  // 将 Dog 类型赋值给 Speaker 类型的变量    speaker.speak()  // 调用 speak 方法，自动认为 dog 实现了 Speaker interface}

Go 这样设计的目的还是希望在做系统设计时能更加关注与具体的功能的实现，而不是 interface 的设计。interface 可以在后期根据需求自动适配，而无需修改已有代码的定义语法。因为只要这个类型实现了 interface 要求的方法，它就可以与该 interface 交互，适应不同的场景。

还是上面“类型作为 interface 类型的参数传递”的例子，introduce 方法接受的是实现了 Speakerinterface 的类型，但在 Go 里面，introduce 的本质是接受所有实现了 speak 方法的类型。至于这个类型来自于你自己本地的代码，还是第三方依赖库都没关系。introduce 方法都认为是实现了 Speaker 的 interface。

所以 Gointerface 是一种“后期引入抽象”的设计，也就时我们反复在说的 interface 的设计不需要事先规划，可以在后面按需定义。Go 鼓励我们在开始时不必过早定义所有 interface，尤其是那些在未来可能会变化的 interface。通过灵活地使用 interface，开发者可以根据需求逐步引入 interface，而不必一开始就把所有 interface 设计好，从而丧失了后期修改扩展的灵活性。来看个例子，假设你正在编写一个日志系统，最开始你只需要一个简单的日志记录功能。此时，你可能不需要定义复杂的 interface，只需关注实际的功能实现。但随着需求的变化，你可能需要让日志系统支持不同的输出方式，比如写入文件、输出到控制台或发送到远程服务器。

package main

import "fmt"

// 初始的简单日志实现type Logger struct{}

func (l Logger) Log(message string) {    fmt.Println(message)}

func main() {    logger := Logger{}    logger.Log("This is a simple log message.")}

一开始，我们没有定义 interface，而是直接通过一个简单的 Logger 类型来实现日志功能。但随着需求的增加，比如需要将日志输出到不同的地方，我们可以在后期定义 interface 并调整代码结构。当你决定支持多种日志输出方式时，可以引入 interface，而不用重构原来的代码。你可以逐步引入 interface 并进行扩展。

type LoggerInterface interface {    Log(message string)}

type Logger struct{}

func (l Logger) Log(message string) {    fmt.Println(message)}

type FileLogger struct{}

func (f FileLogger) Log(message string) {    // 假设写入文件    fmt.Println("File: " + message)}

func logMessage(logger LoggerInterface, message string) {    logger.Log(message)}

func main() {    consoleLogger := ConsoleLogger{}    logMessage(consoleLogger, "This is a console log.")

    fileLogger := FileLogger{}    logMessage(fileLogger, "This is a file log.")}

在这个例子中，我们初期没有定义 interface，而是直接实现了一个简单的日志功能。随着需求的变化，我们才逐步引入了 LoggerInterface interface，这样可以让 ConsoleLogger 和 FileLogger 分别实现 interface，并且不需要修改之前的代码。

这种设计思想就更像是把 interface 当成了扩展，后期再抽象的手段，而不是一开始就设计好的约束。因为你可以在后期编码的过程中发现某些类型都类似或相同的功能，比如坦克，玩具熊，人类都有发声的功能，也许都定义了一个 Speak 的方法。而你在程序中又想对这个 Speak 方法做点什么事情，那你就可以定义一个 Speaker 的 interface，直接使用 Speaker 这个 interface 来直接调用 Speak 方法，而不需要修改前期定义的坦克，玩具熊，人类的代码。

小 interface

在 Go 语言中，interface 通常用于将那些可能会扩展或变化的功能隔离出来，使得程序能够灵活地应对未来可能的变动，而不必在最初的设计阶段就确定好所有的 interface。所以 Go 的 interface 定义倾向于使用简单，短小的 interface 定义。假设你正在编写一个用于文件处理的程序，初期你只需要支持读取文件内容。你可以开始时定义一个简单的 Reader interface，只包含一个方法 Read，这个 interface 可能只有一个方法。

package main

import "fmt"

// 定义一个简单的 interfacetype Reader interface {    Read() string}

type File struct{}

func (f File) Read() string {    return "Reading from file"}

func main() {    var reader Reader = File{}    fmt.Println(reader.Read())}

这个 Reader interface 只包含了一个方法 Read，这在初期完全足够。然而，随着需求的扩展，你可能需要对不同的文件类型进行操作，比如处理文本文件和二进制文件。你可以根据新的需求再引入新的 interface，而不需要修改现有的 Reader interface。

// 新增一个 interfacetype Writer interface {    Write(data string)}

type File struct{}

func (f File) Read() string {    return "Reading from file"}

func (f File) Write(data string) {    fmt.Println("Writing data to file:", data)}

func main() {    var reader Reader = File{}    var writer Writer = File{}    fmt.Println(reader.Read())    writer.Write("Hello, world!")}

在这里，Writer interface 是在原始设计后添加的，它允许你将 File 类型同时作为 Reader 和 Writer 使用。你不需要重构原来的代码，只需扩展现有的类型。

空 interface

空 interface（interface{}）是 Go 语言中非常特别的一个概念。它是一个没有任何方法签名的 interface，表示任意类型。

通用数据存储

由于空 interface 可以表示任何类型的数据，它非常适合用来作为通用数据容器，特别是在不知道具体数据类型的情况下。例如，可以在实现一些容器、函数或者库时使用空 interface 来接收或存储各种不同类型的数据。

func Print(v interface{}) {    fmt.Println(v)}

func main() {    Print(42)           // 打印 int    Print("hello")      // 打印 string    Print([]int{1, 2})  // 打印 slice}

在这个例子中，Print() 函数接受任何类型的参数，并通过空 interface 将其打印出来。这使得 Go 在处理不同类型时，能够保持灵活性与简洁性。

处理未知类型的数据

空 interface 常用于需要处理未知类型数据的场景。例如，某些函数可能会接受各种类型的数据，或者你正在与外部数据源（如 JSON 数据、数据库查询结果等）交互，这时空 interface 非常适合。

package main

import (    "encoding/json"    "fmt")

func main() {    // 示例 JSON 数据    data := `{"name": "Alice", "age": 30, "isStudent": false}`

    // 将 JSON 解码为一个 map，但是 map 的 value 类型不是确定的    var result map[string]interface{}    if err := json.Unmarshal([]byte(data), &result); err != nil {        fmt.Println(err)    }

    // 使用类型断言提取具体值    name := result["name"].(string)    age := result["age"].(float64)    isStudent := result["isStudent"].(bool)

    fmt.Println("Name:", name)    fmt.Println("Age:", age)    fmt.Println("Is Student:", isStudent)}

作为返回值类型

空 interface 可以作为函数的返回类型，特别是在需要返回不确定类型的值时。例如，函数可能会根据某些条件返回不同类型的数据。

package main

import "fmt"

func getData(isString bool) interface{} {    if isString {        return "Hello, World!"    }    return 42}

func main() {    data := getData(true)    fmt.Println(data)

    data = getData(false)    fmt.Println(data)}

可变参数函数

空 interface 可以用来实现可变参数函数，使得函数可以接受不同类型的参数。这对于一些通用的、需要接受不确定类型参数的函数非常有用。

package main

import "fmt"

func printValues(values ...interface{}) {    for _, v := range values {        fmt.Println(v)    }}

func main() {    printValues(1, "hello", 3.14, true)}

类型断言

空 interface 的一个常见使用场景是与类型断言结合使用。通过类型断言，你可以将空 interface 中的具体值恢复为特定类型，这样就能根据实际类型来处理数据。

package main

import "fmt"

func printType(value interface{}) {    switch v := value.(type) {    case int:        fmt.Println("Integer:", v)    case string:        fmt.Println("String:", v)    default:        fmt.Println("Unknown type")    }}

func main() {    printType(42)        // 输出: Integer: 42    printType("hello")   // 输出: String: hello    printType(3.14)      // 输出: Unknown type}

类型断言可以确保从空 interface 中提取的数据符合预期类型。如果类型不匹配，Go 会返回一个布尔值 ok，表明断言是否成功。

总结

Go 语言中的 interface 提供了极高的灵活性和抽象能力，使得代码更加简洁、解耦，并支持高效的多态和灵活的扩展。通过理解 Rob Pike 的设计思想、interface 的基本格式、空 interface 的作用，以及如何在高阶编程中巧妙运用 interface，开发者可以更好地发挥 Go 语言的优势，编写出更具扩展性和可维护性的代码。

谢谢关注！更多内容可以到公众号学习：