接口进阶

接口组合

基本语法

在接口定义中嵌入其他接口，新接口将自动获得所有嵌入接口的方法：

package main

import "fmt"

// 定义小接口
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  // 嵌入 Reader
    Writer  // 嵌入 Writer
}

type ReadWriteCloser interface {
    Reader  // 嵌入 Reader
    Writer  // 嵌入 Writer
    Closer  // 嵌入 Closer
}

// 也可以组合已组合的接口
type ReadWriteSeeker interface {
    ReadWriter        // 嵌入已组合的 ReadWriter
    Seek(offset int64, whence int) (int64, error)  // 额外的方法
}

接口组合的实际应用

package main

import (
    "fmt"
    "io"
    "os"
)

// 定义自己需要的行为接口
type FileReader interface {
    io.Reader
    io.Seeker  // 支持随机读取
    io.Closer  // 支持关闭
}

func readLastN(r FileReader, n int64) ([]byte, error) {
    // 使用 Seek 移动到文件末尾
    size, err := r.Seek(0, io.SeekEnd)
    if err != nil {
        return nil, err
    }

    // 从末尾往前定位
    _, err = r.Seek(size-n, io.SeekStart)
    if err != nil {
        return nil, err
    }

    // 读取最后 n 字节
    data := make([]byte, n)
    _, err = io.ReadFull(r, data)
    return data, err
}

func main() {
    file, err := os.Open("example.txt")
    if err != nil {
        fmt.Println("打开文件失败:", err)
        return
    }
    defer file.Close()

    // os.File 同时实现了 Reader、Seeker、Closer
    data, err := readLastN(file, 10)
    if err != nil {
        fmt.Println("读取失败:", err)
        return
    }
    fmt.Printf("最后 10 字节: %s\n", data)
}

接口嵌入方法与嵌入接口

除了嵌入接口，还可以在接口中直接声明额外的方法：

type ReadWriteCloser interface {
    Reader
    Writer
    Closer
    // 可以添加额外的方法
    Flush() error  // 刷新缓冲区
}

接口的零值

零值行为

接口的零值是 nil，表示既没有类型信息也没有值：

package main

import "fmt"

type Speaker interface {
    Speak() string
}

func main() {
    var s Speaker  // 零值是 nil

    fmt.Println(s == nil)  // true
    fmt.Printf("值: %v, 类型: %T\n", s, s)
    // 值: <nil>, 类型: <nil>

    // 对 nil 接口调用方法会 panic
    // s.Speak()  // panic: runtime error: invalid memory address or nil pointer dereference

    // 安全的调用方式
    if s != nil {
        fmt.Println(s.Speak())
    } else {
        fmt.Println("接口值为 nil，不能调用方法")
    }
}

nil 接口 vs 非 nil 接口中的 nil 值

package main

import "fmt"

type MyError struct{ Msg string }
func (e *MyError) Error() string { return e.Msg }

type Handler interface {
    Handle() error
}

type MyHandler struct{}

func (h *MyHandler) Handle() error {
    var err *MyError = nil
    return err  // 返回有类型的 nil
}

func main() {
    var handler Handler = &MyHandler{}

    err := handler.Handle()
    fmt.Printf("err == nil: %v\n", err == nil)  // false
    fmt.Printf("err: %T, %v\n", err, err)        // *main.MyError, <nil>
}

指针接收者 vs 值接收者对接口实现的影响

方法集规则图解

类型 T 的方法集:
┌──────────────────────────┐
│ func (t T) MethodA()     │  ✅ 值接收者方法
│ func (t T) MethodB()     │  ✅ 值接收者方法
└──────────────────────────┘

类型 *T 的方法集:
┌──────────────────────────┐
│ func (t T) MethodA()     │  ✅ 值接收者方法（继承）
│ func (t T) MethodB()     │  ✅ 值接收者方法（继承）
│ func (t *T) MethodC()    │  ✅ 指针接收者方法
│ func (t *T) MethodD()    │  ✅ 指针接收者方法
└──────────────────────────┘

对接口的影响

package main

import "fmt"

type Sayer interface {
    Say() string
}

type Modifier interface {
    Modify()
}

// 值接收者方法
func (p Person) Say() string {
    return p.Name + " says hello"
}

// 指针接收者方法
func (p *Person) Modify() {
    p.Name = "Modified"
}

type Person struct {
    Name string
}

func main() {
    p := Person{Name: "Alice"}

    // Say 是值接收者：T 和 *T 都满足 Sayer
    var s1 Sayer = p       // ✅ 值可以直接赋给接口
    var s2 Sayer = &p      // ✅ 指针也可以赋给接口
    fmt.Println(s1.Say())  // Alice says hello
    fmt.Println(s2.Say())  // Alice says hello

    // Modify 是指针接收者：只有 *T 满足 Modifier
    var m1 Modifier = &p   // ✅ 指针满足 Modifier
    m1.Modify()
    fmt.Println(p.Name)    // Modified

    // var m2 Modifier = p  // ❌ 编译错误：Person 没有实现 Modifier
}

深入理解：为什么指针接收者更严格

package main

import "fmt"

type Counter struct {
    count int
}

// 值接收者：不会修改原始值
func (c Counter) Value() int {
    return c.count
}

// 指针接收者：可以修改原始值
func (c *Counter) Increment() {
    c.count++
}

type CounterInterface interface {
    Value() int
    Increment()
}

func process(c CounterInterface) {
    c.Increment()
    fmt.Println(c.Value())
}

func main() {
    // 方式 1：传递指针
    c1 := &Counter{count: 0}
    process(c1)  // 1

    // 方式 2：传递值 ❌ 编译错误
    // c2 := Counter{count: 0}
    // process(c2)  // 编译错误：Counter 没有实现 CounterInterface
}

特殊情况：不可拷贝的类型

import "sync"

type SafeCounter struct {
    mu    sync.Mutex
    count int
}

// 必须使用指针接收者：sync.Mutex 不可拷贝
func (c *SafeCounter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}

// 如果使用值接收者，编译器会报错：
// func (c SafeCounter) Value() int {
//     return c.count  // 编译错误：sync.Mutex 的复制
// }

小接口原则

Go 标准库中的小接口典范

// io 包 —— 每个接口只有 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 Seeker interface {
    Seek(offset int64, whence int) (int64, error)
}

// 通过组合构建更大的接口
type ReadWriter interface {
    Reader
    Writer
}

type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

type ReadWriteSeeker interface {
    Reader
    Writer
    Seeker
}

小接口的优势

实战示例：设计小接口

// ❌ 大接口：不好
type UserService interface {
    GetUser(id int) (*User, error)
    CreateUser(user *User) error
    UpdateUser(user *User) error
    DeleteUser(id int) error
    ListUsers(page, size int) ([]*User, error)
    SearchUsers(query string) ([]*User, error)
    ResetPassword(id int) error
    ChangeRole(id int, role string) error
}

// ✅ 拆分为小接口
// 只读操作
type UserReader interface {
    GetUser(id int) (*User, error)
    ListUsers(page, size int) ([]*User, error)
    SearchUsers(query string) ([]*User, error)
}

// 只写操作
type UserWriter interface {
    CreateUser(user *User) error
    UpdateUser(user *User) error
    DeleteUser(id int) error
}

// 权限管理
type RoleManager interface {
    ChangeRole(id int, role string) error
    ResetPassword(id int) error
}

// 完整服务 = 小接口组合
type UserService interface {
    UserReader
    UserWriter
    RoleManager
}

// 小接口让函数只需声明它真正需要的最小行为
func PrintUserName(r UserReader, id int) {
    user, err := r.GetUser(id)
    if err != nil {
        fmt.Println("错误:", err)
        return
    }
    fmt.Println(user.Name)
}

// 这个函数只需要读操作，传入完整 UserService 也可以
// 但类型签名告诉调用者：这个函数不会修改数据

接口隔离原则

违反接口隔离原则的例子

// ❌ 违反 ISP：臃肿的接口
type Animal interface {
    Walk()
    Fly()
    Swim()
    MakeSound()
    Eat()
    Sleep()
}

// 狗不会飞，却被迫实现 Fly()
type Dog struct{}
func (d Dog) Walk()    { fmt.Println("狗在走") }
func (d Dog) Fly()     { /* 不会飞！被迫空实现 */ }
func (d Dog) Swim()    { fmt.Println("狗在游") }
func (d Dog) MakeSound() { fmt.Println("汪汪！") }
func (d Dog) Eat()     { fmt.Println("狗在吃") }
func (d Dog) Sleep()   { fmt.Println("狗在睡") }

遵循接口隔离原则的改进

// ✅ 遵循 ISP：拆分为小接口
type Walker interface {
    Walk()
}

type Flyer interface {
    Fly()
}

type Swimmer interface {
    Swim()
}

type SoundMaker interface {
    MakeSound()
}

// 每个类型只实现它需要的接口
type Dog struct{}

func (d Dog) Walk()       { fmt.Println("狗在走") }
func (d Dog) Swim()       { fmt.Println("狗在游") }
func (d Dog) MakeSound()  { fmt.Println("汪汪！") }

type Bird struct{}

func (b Bird) Walk()      { fmt.Println("鸟在走") }
func (b Bird) Fly()       { fmt.Println("鸟在飞") }
func (b Bird) MakeSound() { fmt.Println("叽叽！") }

type Fish struct{}

func (f Fish) Swim()      { fmt.Println("鱼在游") }

// 函数只依赖它需要的最小接口
func LetWalk(w Walker)    { w.Walk() }
func LetFly(f Flyer)      { f.Fly() }
func LetSwim(s Swimmer)   { s.Swim() }

func main() {
    dog := Dog{}
    LetWalk(dog)   // 狗在走
    LetSwim(dog)   // 狗在游
    // LetFly(dog)  // 编译错误：Dog 没有实现 Flyer — 编译期就能发现问题！

    bird := Bird{}
    LetWalk(bird)  // 鸟在走
    LetFly(bird)   // 鸟在飞

    fish := Fish{}
    LetSwim(fish)  // 鱼在游
}

接口设计的实用建议

// Go 推荐：使用方定义接口（消费端定义）
// 定义在包的使用方，而不是实现方

// package consumer（使用方）
type ItemStorer interface {
    Store(item Item) error
    Retrieve(id string) (Item, error)
}

// package memory（实现方）
type MemoryStore struct {
    items map[string]Item
}

func (m *MemoryStore) Store(item Item) error { ... }
func (m *MemoryStore) Retrieve(id string) (Item, error) { ... }
// MemoryStore 只需要实现 ItemStorer 要求的方法

练习题

练习 1：接口组合与方法集

分析以下代码，判断哪些赋值是合法的，哪些会编译错误，并说明原因。

package main

type Reader interface {
    Read() string
}

type Writer interface {
    Write(s string)
}

type ReadWriter interface {
    Reader
    Writer
}

type Closer interface {
    Close()
}

type MyType struct{}

func (m MyType) Read() string       { return "data" }
func (m *MyType) Write(s string)    { /* write */ }
func (m *MyType) Close()            { /* close */ }

func main() {
    var r Reader = MyType{}
    var w Writer = &MyType{}
    var rw ReadWriter = MyType{}
    var rw2 ReadWriter = &MyType{}
    var c Closer = MyType{}
    var c2 Closer = &MyType{}
}

练习 2：小接口设计实践

为一个日志系统设计接口。要求遵循小接口原则，支持以下功能：

1. 写入日志消息
2. 关闭日志资源
3. 刷新缓冲区（可选功能）
4. 设置日志级别（可选功能）

编写一个 ConsoleLogger 实现核心接口，以及一个 FileLogger 实现所有接口。

package main

import (
    "fmt"
    "os"
    "time"
)

// 核心接口：所有日志器必须实现
type LogWriter interface {
    WriteLog(level, message string)
    Close() error
}

// 可选接口：支持缓冲区刷新
type LogFlusher interface {
    Flush() error
}

// 可选接口：支持日志级别设置
type LogLeveller interface {
    SetLevel(level string)
}

// 完整接口：核心 + 所有可选
type FullLogger interface {
    LogWriter
    LogFlusher
    LogLeveller
}

// === ConsoleLogger：仅实现核心接口 ===
type ConsoleLogger struct{}

func (c *ConsoleLogger) WriteLog(level, message string) {
    fmt.Printf("[%s] %s: %s\n", time.Now().Format("15:04:05"), level, message)
}

func (c *ConsoleLogger) Close() error {
    fmt.Println("控制台日志关闭")
    return nil
}

// === FileLogger：实现所有接口 ===
type FileLogger struct {
    file  *os.File
    level string
}

func NewFileLogger(filename string) (*FileLogger, error) {
    f, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        return nil, err
    }
    return &FileLogger{file: f, level: "INFO"}, nil
}

func (f *FileLogger) WriteLog(level, message string) {
    line := fmt.Sprintf("[%s] %s: %s\n", time.Now().Format("2006-01-02 15:04:05"), level, message)
    f.file.WriteString(line)
}

func (f *FileLogger) Close() error {
    return f.file.Close()
}

func (f *FileLogger) Flush() error {
    return f.file.Sync()
}

func (f *FileLogger) SetLevel(level string) {
    f.level = level
}

// === 函数只依赖它需要的最小接口 ===
func WriteInfo(w LogWriter, message string) {
    w.WriteLog("INFO", message)
}

func FlushIfPossible(w LogWriter) {
    if flusher, ok := w.(LogFlusher); ok {
        flusher.Flush()
        fmt.Println("缓冲区已刷新")
    }
}

func main() {
    // ConsoleLogger 只实现了核心接口
    console := &ConsoleLogger{}
    WriteInfo(console, "控制台日志消息")
    FlushIfPossible(console)  // 不会刷新（不支持 LogFlusher）
    console.Close()

    fmt.Println("---")

    // FileLogger 实现了所有接口
    file, _ := NewFileLogger("app.log")
    WriteInfo(file, "文件日志消息")
    FlushIfPossible(file)  // 缓冲区已刷新
    file.Close()
}

练习 3：方法集与接口满足

以下代码中哪些函数调用会编译通过？哪些会编译失败？解释原因。

package main

import "fmt"

type Greeter interface {
    Greet() string
}

type Modifier interface {
    Modify()
}

type Entity struct {
    value string
}

func (e Entity) Greet() string {
    return "Hello, " + e.value
}

func (e *Entity) Modify() {
    e.value = "Modified"
}

func doGreet(g Greeter) { fmt.Println(g.Greet()) }
func doModify(m Modifier) { m.Modify() }

func main() {
    e := Entity{value: "World"}

    doGreet(e)
    doGreet(&e)
    doModify(e)
    doModify(&e)
}

Cannot use 'e' (type Entity) as type Modifier
Type does not implement 'Modifier' as 'Modify' method has a pointer receiver

T 的方法集 = {值接收者方法}
*T 的方法集 = {值接收者方法} ∪ {指针接收者方法}