Go 接口：interface 定义与实现

Go 语言中的 interface 是一种类型，用于定义一组方法签名。任何类型只要实现了这些方法，就被认为实现了该接口。这种机制不依赖显式声明，而是通过隐式满足来完成，让代码更灵活、解耦更强。

定义一个 interface

创建一个接口类型，使用 type 关键字后跟接口名和 interface 关键字，再在花括号 {} 内列出方法签名（只有方法名、参数和返回值，没有具体实现）。

例如，定义一个能“说话”的接口：

type Speaker interface {
    Speak() string
}

这个 Speaker 接口要求实现者提供一个名为 Speak 的方法，该方法不接收参数，返回一个 string。

实现 interface

Go 中不需要显式声明“我实现了某个接口”。只要你的类型拥有接口中定义的所有方法，它就自动实现了该接口。

步骤：

1. 定义一个结构体（或其他类型）。
2. 为该类型编写方法，其签名必须与接口中的方法完全一致（包括名称、参数列表和返回值）。
3. 无需额外声明，该类型即被视为实现了该接口。

例如：

type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return "Woof! I'm " + d.Name
}

此时，Dog 类型已经实现了 Speaker 接口，因为它的 Speak() 方法签名与接口定义完全匹配。

你可以将 Dog 实例赋值给 Speaker 类型的变量：

var s Speaker = Dog{Name: "Buddy"}
fmt.Println(s.Speak()) // 输出: Woof! I'm Buddy

多个类型实现同一个 interface

不同类型的对象可以实现同一个接口，这是多态的基础。

继续上面的例子，再定义一个 Cat：

type Cat struct {
    Name string
}

func (c Cat) Speak() string {
    return "Meow! My name is " + c.Name
}

现在 Cat 也实现了 Speaker 接口。你可以写一个通用函数处理所有 Speaker：

func MakeSound(s Speaker) {
    fmt.Println(s.Speak())
}

// 调用
MakeSound(Dog{Name: "Max"})
MakeSound(Cat{Name: "Luna"})

输出：

Woof! I'm Max
Meow! My name is Luna

空 interface：interface{}

interface{} 是一个特殊的接口，它不包含任何方法。由于所有类型都至少有零个方法，因此 所有类型都实现了空接口。

这使得 interface{} 可以接收任意类型的值，类似于其他语言中的“任意类型”（如 Java 的 Object 或 Python 的 object）。

例如：

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

PrintAnything(42)
PrintAnything("hello")
PrintAnything(Dog{Name: "Rex"})

注意：从 Go 1.18 起，推荐使用 any 作为 interface{} 的别名，语义更清晰：

func PrintAnything(v any) { ... }

类型断言：从 interface 获取具体类型

当你有一个接口变量，但需要访问其底层具体类型的字段或特有方法时，使用类型断言。

语法：value, ok := interfaceVariable.(ConcreteType)

例如：

var s Speaker = Dog{Name: "Fido"}

if dog, ok := s.(Dog); ok {
    fmt.Println("This dog's name is", dog.Name)
}

• 如果 s 的底层类型确实是 Dog，ok 为 true，dog 就是 Dog 类型的值。
• 如果不是，ok 为 false，dog 是 Dog 的零值。

不要省略 ok 检查，否则类型不匹配时程序会 panic。

接口组合

Go 支持接口嵌套，即一个接口可以包含其他接口的方法。

例如：

type Walker interface {
    Walk() string
}

type Runner interface {
    Run() string
}

type Athlete interface {
    Walker
    Runner
}

此时，Athlete 接口包含了 Walk() 和 Run() 两个方法。任何类型只要同时实现这两个方法，就实现了 Athlete。

常见误区与最佳实践

何时使用 interface

优先在消费者端定义接口。也就是说，如果你写一个函数需要某种能力（比如“能保存数据”），先定义一个描述该能力的接口，而不是让调用方去适配你的结构。

例如，不要这样：

func SaveToFile(f FileStruct) { ... } // 依赖具体类型

而应该：

type Saver interface {
    Save(data string) error
}

func SaveData(s Saver, data string) {
    s.Save(data)
}

这样，任何实现了 Save 方法的类型（文件、数据库、网络服务等）都可以被 SaveData 使用。

零值与 nil 接口

接口的零值是 nil。但要注意：一个非 nil 的具体值包装成接口后，接口本身不为 nil。

容易出错的例子：

var d *Dog = nil
var s Speaker = d
fmt.Println(s == nil) // 输出 false！

虽然 d 是 nil，但 s 的类型是 *Dog，值是 nil，所以整个接口变量不等于 nil。比较接口是否“真正为空”，应同时检查类型和值。

安全做法：避免将 nil 具体值赋给接口变量，或在函数内部做双重检查。

package main

import "fmt"

type Speaker interface {
    Speak() string
}

type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return "Woof! I'm " + d.Name
}

type Cat struct {
    Name string
}

func (c Cat) Speak() string {
    return "Meow! My name is " + c.Name
}

func MakeSound(s Speaker) {
    fmt.Println(s.Speak())
}

func main() {
    MakeSound(Dog{Name: "Buddy"})
    MakeSound(Cat{Name: "Whiskers"})
}