Go 接口与组合

3 min中级2026/10/11

接口定义、隐式实现、空接口、类型断言、类型开关、接口组合、io.Reader/Writer、sort.Interface 与常见接口模式。

学习目标

理解接口的隐式实现与”方法集”规则，能判断值类型与指针类型各满足哪些接口。
掌握空接口 any、类型断言与类型开关的用法与边界。
说清”接口为 nil”与”接口内指针为 nil”的区别，避开经典陷阱。
会用接口组合与 io.Reader/Writer 抽象构建可插拔的代码结构。

1. 接口定义

1.1 基本语法

// 接口是一组方法签名的集合
type Shape interface {
    Area() float64
    Perimeter() float64
}

// 接口可以嵌入其他接口
type Geometry interface {
    Shape
    Volume() float64
}

1.2 接口底层结构

接口值在运行时由两部分组成：

flowchart LR
    TD[类型指针 type descriptor] -->|具体类型信息| T
    DP[数据指针 data pointer] -->|实际值的副本（或指针）| T

mermaid diagram

var s Shape = Circle{Radius: 5}
// 接口值 = (type: Circle, data: &Circle{Radius: 5})

var s2 Shape  // nil 接口值 = (type: nil, data: nil)

重要：接口值为 nil 不等于接口内部的值为 nil：

var p *Circle = nil
var s Shape = p
fmt.Println(s == nil) // false！类型部分不是 nil
// 这是 Go 常见陷阱

2. 隐式实现

2.1 实现规则

类型只需实现接口的所有方法，即自动满足接口，无需 implements 关键字：

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

// 任何有 Write 方法的类型都实现了 Writer
type BufferedWriter struct {
    buf []byte
}

func (w *BufferedWriter) Write(p []byte) (int, error) {
    w.buf = append(w.buf, p...)
    return len(p), nil
}

var w Writer = &BufferedWriter{} // 隐式实现

一个接口最常见的价值是一接口多实现：调用方只依赖接口，任何满足方法集的类型都能传入（下例两个不相关的类型都实现了 Speaker）：

type Dog struct{ Name string }

func (d Dog) Speak() string {
    return d.Name + " says: Woof!"
}

type Robot struct{ ID int }

func (r Robot) Speak() string {
    return fmt.Sprintf("Robot #%d says: Beep!", r.ID)
}

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

makeItSpeak(Dog{Name: "Rex"}) // Rex says: Woof!
makeItSpeak(Robot{ID: 42})    // Robot #42 says: Beep!

2.3 方法集：值接收者与指针接收者的分界

隐式实现最重要的细则藏在**方法集（method set）**里：类型 T 的方法集只包含值接收者方法；*T 的方法集包含值接收者与指针接收者全部方法。推论是——指针接收者的方法只有指针类型能”带进”接口：

type Counter interface {
    Inc()
    Value() int
}

type hits struct{ n int }

func (h *hits) Inc()     { h.n++ } // 指针接收者
func (h hits) Value() int { return h.n }

var c Counter = &hits{}   // 正确：*hits 的方法集包含 Inc 与 Value
// var c Counter = hits{} // 编译错误：hits 的方法集只有 Value，未实现 Inc

text

# 若取消注释，编译报错：
cannot use hits{} (value of type hits) as Counter value:
hits does not implement Counter (method Inc has pointer receiver)

记忆方法：值接收者语义上是”副本调用”，编译器不允许通过接口拿到可变的副本；指针接收者意味着方法可能修改状态，因此只有指针能进接口。实践中若拿不准，结构体方法统一用指针接收者是社区常见默认，可避免这类方法集劈叉。

2.4 编译时验证

// 确保 Circle 实现了 Shape 接口
var _ Shape = Circle{}       // 值接收者
var _ Shape = (*Circle)(nil) // 指针接收者

// 如果未实现，编译时会报错
// Circle does not implement Shape (missing Area method)

2.3 接口的优势

解耦：依赖接口而非具体类型
可测试：轻松创建 mock 实现
灵活：任何包的类型都能实现接口，无需修改接口定义

// 依赖接口，而非具体实现
type Notifier interface {
    Notify(message string) error
}

func SendAlert(n Notifier, msg string) error {
    return n.Notify(msg)
}

// 不同实现
type EmailNotifier struct{ Addr string }
func (e *EmailNotifier) Notify(msg string) error { /* 发邮件 */ return nil }

type SMSNotifier struct{ Phone string }
func (s *SMSNotifier) Notify(msg string) error { /* 发短信 */ return nil }

// 测试 mock
type MockNotifier struct{ Called bool }
func (m *MockNotifier) Notify(msg string) error { m.Called = true; return nil }

3. 空接口

3.1 any 类型

Go 1.18 将 interface{} 别名为 any：

// 两者完全等价
var v1 interface{} = 42
var v2 any = 42

// 常见用途
func Print(v any) {
    fmt.Printf("type: %T, value: %v\n", v, v)
}

3.2 空接口的使用场景

// 1. JSON 解析
var result any
json.Unmarshal(data, &result)

// 2. 通用容器
type Stack struct {
    items []any
}
func (s *Stack) Push(v any)  { s.items = append(s.items, v) }
func (s *Stack) Pop() any    { n := len(s.items) - 1; v := s.items[n]; s.items = s.items[:n]; return v }

// 3. fmt.Println 参数
func Println(a ...any) (n int, err error)

建议：尽量避免使用 any，优先使用具体接口以获得类型安全。

4. 类型断言

4.1 基本形式

var w Writer = &BufferedWriter{}

// 断言（不安全，失败则 panic）
bw := w.(*BufferedWriter)

// 逗号 ok 模式（安全）
bw, ok := w.(*BufferedWriter)
if ok {
    fmt.Println("是 *BufferedWriter")
}

// 断言为非实现类型
_, ok := w.(*os.File)
fmt.Println(ok) // false

4.2 从接口提取值

func getString(v any) string {
    // 尝试多种类型
    if s, ok := v.(string); ok {
        return s
    }
    if s, ok := v.(fmt.Stringer); ok {
        return s.String()
    }
    if b, ok := v.([]byte); ok {
        return string(b)
    }
    return fmt.Sprintf("%v", v)
}

5. 类型开关

类型开关是处理多类型接口值的惯用方式：

func describe(v any) string {
    switch v := v.(type) {
    case nil:
        return "nil"
    case int:
        return fmt.Sprintf("int: %d", v)
    case float64:
        return fmt.Sprintf("float64: %f", v)
    case string:
        return fmt.Sprintf("string: %q", v)
    case bool:
        return fmt.Sprintf("bool: %t", v)
    case []int:
        return fmt.Sprintf("[]int: %v (len=%d)", v, len(v))
    case fmt.Stringer:
        return fmt.Sprintf("Stringer: %s", v.String())
    case error:
        return fmt.Sprintf("error: %v", v)
    default:
        return fmt.Sprintf("unknown: %T", v)
    }
}

6. 接口组合

6.1 接口嵌入接口

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

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

type Closer interface {
    Close() error
}

// 组合接口
type ReadWriter interface {
    Reader
    Writer
}

type ReadCloser interface {
    Reader
    Closer
}

type WriteCloser interface {
    Writer
    Closer
}

type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

6.2 结构体嵌入接口

// 结构体可以嵌入接口，实现部分默认行为
type Logger struct {
    Writer // 嵌入 Writer 接口
}

func (l *Logger) Log(msg string) {
    l.Write([]byte(msg + "\n"))
}

// 使用时注入具体实现
logger := Logger{Writer: os.Stdout}
logger.Log("Hello")

7. 标准库核心接口

7.1 io.Reader / io.Writer

// io.Reader — 读取数据的核心抽象
type Reader interface {
    Read(p []byte) (n int, err error)
}

// io.Writer — 写入数据的核心抽象，只有一个方法
type Writer interface {
    Write(p []byte) (n int, err error)
}

// 实现自定义 Reader
type UpperReader struct {
    src io.Reader
}

func (u *UpperReader) Read(p []byte) (int, error) {
    n, err := u.src.Read(p)
    for i := 0; i < n; i++ {
        if p[i] >= 'a' && p[i] <= 'z' {
            p[i] -= 32 // 转大写
        }
    }
    return n, err
}

// 链式组合 Reader
reader := &UpperReader{src: strings.NewReader("hello world")}
data, _ := io.ReadAll(reader)
fmt.Println(string(data)) // HELLO WORLD

7.2 fmt.Stringer / error

// fmt.Stringer — 自定义字符串表示
type Point struct{ X, Y int }

func (p Point) String() string {
    return fmt.Sprintf("(%d, %d)", p.X, p.Y)
}

fmt.Println(Point{3, 4}) // (3, 4)

// error 接口
type error interface {
    Error() string
}

7.3 sort.Interface

type Interface interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}

// 自定义排序
type ByAge []User

func (a ByAge) Len() int           { return len(a) }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

users := []User{{"Alice", 30}, {"Bob", 25}, {"Charlie", 35}}
sort.Sort(ByAge(users))

// Go 1.21+ 使用 slices.SortFunc 更简洁
slices.SortFunc(users, func(a, b User) int {
    return cmp.Compare(a.Age, b.Age)
})

7.4 io.Closer / io.Seeker

type Closer interface {
    Close() error
}

type Seeker interface {
    Seek(offset int64, whence int) (int64, error)
}

// 文件同时实现 Reader/Writer/Closer/Seeker
file, _ := os.Open("data.txt")
// file 实现了 io.ReadCloser, io.ReadSeeker, io.ReadWriteCloser 等

8. 常见接口模式

8.1 小接口原则

// 好：接口应该小而专注
type Getter interface {
    Get(key string) (any, error)
}

// 坏：接口太大，难以实现和复用
type DataStore interface {
    Get(key string) (any, error)
    Set(key string, val any) error
    Delete(key string) error
    List() ([]string, error)
    Watch(key string) (<-chan Event, error)
}

Go 谚语：“The bigger the interface, the weaker the abstraction.” — Rob Pike

8.2 消费者定义接口

// 在使用方定义接口，而非提供方
// 服务包
package storage

type RedisClient struct { /* ... */ }
func (r *RedisClient) Get(key string) (string, error) { /* ... */ }
func (r *RedisClient) Set(key, val string) error       { /* ... */ }

// 消费方包
package service

// 只声明需要的方法
type KeyGetter interface {
    Get(key string) (string, error)
}

func GetValue(g KeyGetter, key string) (string, error) {
    return g.Get(key)
}
// RedisClient 自动满足 KeyGetter，无需修改 storage 包

8.3 接口与 nil

// 正确检查接口是否为 nil
func isNil(v any) bool {
    if v == nil {
        return true
    }
    // 反射检查值是否为 nil（指针、切片、map、channel）
    rv := reflect.ValueOf(v)
    switch rv.Kind() {
    case reflect.Ptr, reflect.Slice, reflect.Map,
         reflect.Chan, reflect.Interface, reflect.Func:
        return rv.IsNil()
    }
    return false
}

8.4 接口作为返回值

// 工厂函数返回接口
func NewStorage(cfg Config) (Storage, error) {
    switch cfg.Type {
    case "redis":
        return newRedisStorage(cfg)
    case "mysql":
        return newMySQLStorage(cfg)
    case "memory":
        return newMemoryStorage(cfg)
    default:
        return nil, fmt.Errorf("unsupported storage: %s", cfg.Type)
    }
}

Go 接口与组合

学习目标#

1. 接口定义#

1.1 基本语法#

1.2 接口底层结构#

2. 隐式实现#

2.1 实现规则#

2.3 方法集：值接收者与指针接收者的分界#

2.4 编译时验证#

2.3 接口的优势#

3. 空接口#

3.1 any 类型#

3.2 空接口的使用场景#

4. 类型断言#

4.1 基本形式#

4.2 从接口提取值#

5. 类型开关#

6. 接口组合#

6.1 接口嵌入接口#

6.2 结构体嵌入接口#

7. 标准库核心接口#

7.1 io.Reader / io.Writer#

7.2 fmt.Stringer / error#

7.3 sort.Interface#

7.4 io.Closer / io.Seeker#

8. 常见接口模式#

8.1 小接口原则#

8.2 消费者定义接口#

8.3 接口与 nil#

8.4 接口作为返回值#