Go 接口学习笔记：从语法到心法

刚接触接口的时候，最常听到的一句话就是："Go 的接口是隐式实现的。" 听起来很抽象，但当真正理解之后，会发现它是 Go 里最锋利的一把刀。

---

一、什么是接口

接口定义了一组方法签名 ，但不包含实现。任何类型只要拥有接口里声明的全部方法，它就自动实现了这个接口，不需要像 Java 那样写 implements。

type Speaker interface {
    Speak() string
}

type Dog struct{}
func (d Dog) Speak() string { return "汪汪" }

Dog 有一个 Speak() string 方法，所以它自动就是一个 Speaker。可以直接把 Dog{} 赋给 Speaker 类型的变量：

var s Speaker = Dog{}
fmt.Println(s.Speak()) // 汪汪

这就是鸭子类型 ：如果它叫声像鸭子，那它就是鸭子。实现方甚至不需要知道 Speaker 这个接口的存在，解耦得非常彻底。

---

二、接口变量的内部长什么样

接口变量在底层是一个由类型信息 和数据指针组成的二元组。

• 空接口 interface{}（或 any）：只存（类型，值）。因为没有方法，就是一个能装任何东西的"万能箱子"。
• 有方法的接口 ：除了（类型，值）外，还附带一个方法表，记录每个接口方法对应具体类型的哪个函数。调用方法时，运行时查表跳转，速度很快。

理解这个结构，是避开后面那些坑的基础。

---

三、空接口 any 与类型断言

any 可以接收任意类型的值：

var x any = "hello"
x = 42
x = struct{ Name string }{"Go"}

从 any 里取回原来的值，必须用类型断言：

if s, ok := x.(string); ok {
    fmt.Println("字符串:", s)
} else {
    fmt.Println("不是字符串")
}

重要 ：如果只用一个返回值 s := x.(string)，一旦断言失败程序会直接 panic。永远优先用逗号 ok 模式。

类型选择（Type Switch） 可以一次判断多种类型：

switch v := x.(type) {
case int:
    fmt.Printf("整数 %d\n", v)
case string:
    fmt.Printf("字符串 %s\n", v)
default:
    fmt.Printf("未知类型 %T\n", v)
}

---

四、值接收者 vs 指针接收

方法可以用值接收者，也可以用指针接收者。这对接口的实现有决定性影响。

规则很简单：

• 类型 T 的方法集：只包含所有值接收者的方法。
• 类型 *T 的方法集：包含所有方法（值接收者 + 指针接收者）。

看例子：

type Greeter interface {
    Greet()
}

type Person struct{ Name string }

// 指针接收者实现
func (p *Person) Greet() {
    fmt.Println("Hi, I'm", p.Name)
}

下面的代码会编译失败：

var g Greeter
g = Person{"张三"} // ❌ 编译错误
g = &Person{"张三"} // ✅ 正确

原因是 Person 的方法集里没有 Greet 方法，只有 *Person 才有。为什么？因为编译器不能保证一个值类型能安全地取地址去调用指针接收者的方法。

最佳实践：

• 如果方法需要修改接收者的状态，必须用指针接收者。
• 如果只是一些只读操作，用值接收者更灵活，因为值类型和指针类型都能用。
• 同一个类型不要混用接收者，除非有特别清晰的理由。

---

五、接口的 nil 陷阱

接口只有在动态类型和动态值都为 nil 时，才等于 nil。

var p *int = nil
var i any = p
fmt.Println(i == nil) // false!

这里 i 的动态类型是 *int，虽然值是 nil，但接口本身不是 nil。

更危险的是自定义错误：

type MyError struct{}
func (e *MyError) Error() string { return "my error" }

func getError() error {
    var p *MyError = nil
    return p // 返回的 error 不是 nil！
}

func main() {
    err := getError()
    if err != nil {
        fmt.Println("有错误") // 会执行到这里
    }
}

避坑原则 ：函数返回错误时，直接 return nil，而不是把一个带类型的 nil 指针作为 error 返回。

---

六、接口的组合

小接口能像积木一样拼成大接口：

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

type ReadWriter interface {
    Reader
    Writer
}

要满足 ReadWriter，必须同时实现 Reader 和 Writer 的全部方法。这很像标准库里的 io.ReadWriter。

---

七、设计接口的三条黄金法则

1. 接口尽量小

最好的接口只包含 1~3 个方法。io.Reader 只有一个 Read，但威力无穷。接口越小，适用范围越广，实现成本越低。不要一上来就定义一个巨大的 Repository 接口。

2. 由使用方定义接口

谁用接口，谁定义接口。比如业务模块需要"发通知"的能力，就在业务包定义 Notifier 接口，然后邮件、短信等实现各自独立。这样可以消除包之间的单向依赖。

3. 接受接口，返回结构体

函数参数尽量用接口，这样调用者可以传入任何符合契约的实现（比如测试用的模拟实现）。返回值尽量用具体的结构体，除非有特别的需要隐藏实现细节。

---

八、泛型中的接口（Go 1.18+）

接口又多了一个角色：类型约束。它不仅可以写方法，还能写允许的类型：

type Number interface {
    ~int | ~int32 | ~int64 | ~float32 | ~float64
}

func Add[T Number](a, b T) T {
    return a + b
}

这里的 ~int 表示底层类型是 int 的自定义类型也允许。初学阶段先掌握方法集形式的接口，泛型约束可以循序渐进。

---

九、速查表

概念	要点
实现规则	隐式，只要方法签名匹配
空接口 any	能存任意值，用类型断言取出
指针接收者	只有 *T 实现接口，T 没有
nil 判断	只有类型和数据双 nil，接口才 nil
类型断言	用逗号 ok 模式避免 panic
接口组合	嵌入其他接口，方法集求并集
设计习惯	小接口、消费端定义、接受接口返回结构体

接口不是为了让代码看起来高级，而是为了降低耦合、提高可测试性。当你开始习惯用接口去思考"行为"而不是"类型"时，Go 语言里很多设计都会豁然开朗。