Go之路 - 8.go的接口

1. Go接口的核心：隐式实现

1.1 什么是隐式实现？

Go接口的最大特点：一个类型不需要显式声明它实现了某个接口，只要它拥有接口要求的所有方法，就自动实现了该接口。

// 定义接口
type Speaker interface {
    Speak() string
}

// 定义类型
type Dog struct {
    name string
}

// 为Dog实现Speak方法
func (d Dog) Speak() string {
    return "Woof! I'm " + d.name
}

// 神奇的时刻：Dog自动实现了Speaker接口！
// 不需要写：type Dog implements Speaker

1.2 编译器的自动检查

当你把Dog类型值用于需要Speaker接口的地方时，编译器会：

1. 检查Dog是否有Speak()方法
2. 检查方法签名是否匹配
3. 如果匹配，就自动进行类型转换

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

func main() {
    dog := Dog{name: "Buddy"}
    // 可以传递Dog给需要Speaker的函数
    MakeAnimalSpeak(dog) // ✓ 自动通过检查
    
    // 也可以赋值给接口变量
    var speaker Speaker
    speaker = dog // ✓ 编译器自动确认Dog实现了Speaker
}

2. 基础接口用法

2.1 定义和实现

// 空接口：可以保存任何值
type Any interface{}

// 单方法接口
type Stringer interface {
    String() string
}

// 多方法接口
type ReadWriter interface {
    Read(p []byte) (n int, err error)
    Write(p []byte) (n int, err error)
}

// 嵌套接口
type ReadWriteCloser interface {
    ReadWriter  // 嵌入ReadWriter接口
    Close() error
}

// 实现示例
type File struct {
    name string
}

// 实现Read方法
func (f File) Read(p []byte) (int, error) {
    return len(p), nil
}

// 实现Write方法
func (f File) Write(p []byte) (int, error) {
    return len(p), nil
}

// 实现Close方法
func (f File) Close() error {
    return nil
}

// File现在自动实现了：
// - Reader (如果只使用Read)
// - Writer (如果只使用Write)
// - ReadWriter (因为同时有Read和Write)
// - ReadWriteCloser (因为同时有Read、Write、Close)

3. 接口的常见用法模式

3.1 作为函数参数（多态）

// 定义接口
type Shape interface {
    Area() float64
    Perimeter() float64
}

// 不同实现
type Circle struct{ Radius float64 }
type Rectangle struct{ Width, Height float64 }

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

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

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

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// 使用接口的函数 - 可以接受任何Shape
func PrintShapeInfo(s Shape) {
    fmt.Printf("Area: %.2f, Perimeter: %.2f\n", 
        s.Area(), s.Perimeter())
}

func main() {
    shapes := []Shape{
        Circle{Radius: 5},
        Rectangle{Width: 3, Height: 4},
    }
    
    for _, shape := range shapes {
        PrintShapeInfo(shape)
    }
    // 输出：
    // Area: 78.54, Perimeter: 31.42
    // Area: 12.00, Perimeter: 14.00
}

3.2 接口组合

// 小接口
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 ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

// 实现小接口，自动获得大接口
type Buffer struct {
    data []byte
}

func (b *Buffer) Read(p []byte) (int, error) {
    copy(p, b.data)
    return len(b.data), nil
}

func (b *Buffer) Write(p []byte) (int, error) {
    b.data = append(b.data, p...)
    return len(p), nil
}

func (b *Buffer) Close() error {
    b.data = nil
    return nil
}

// Buffer自动实现了：
// - Reader, Writer, Closer
// - ReadWriter, ReadWriteCloser

4. 空接口的用法

4.1 存储任意类型

// 空接口可以保存任何值
func StoreAnything() {
    var anything interface{}
    
    anything = 42
    fmt.Printf("int: %v\n", anything)
    
    anything = "hello"
    fmt.Printf("string: %v\n", anything)
    
    anything = []int{1, 2, 3}
    fmt.Printf("slice: %v\n", anything)
}

// 作为函数参数
func PrintValue(v interface{}) {
    fmt.Printf("Value: %v, Type: %T\n", v, v)
}

4.2 类型断言

func ProcessValue(v interface{}) {
    // 方法1：类型断言
    if str, ok := v.(string); ok {
        fmt.Printf("是字符串: %s\n", str)
        return
    }
    
    // 方法2：类型switch
    switch val := v.(type) {
    case int:
        fmt.Printf("是整数: %d\n", val)
    case float64:
        fmt.Printf("是浮点数: %.2f\n", val)
    case bool:
        fmt.Printf("是布尔值: %v\n", val)
    case []int:
        fmt.Printf("是整型切片，长度: %d\n", len(val))
    default:
        fmt.Printf("未知类型: %T\n", val)
    }
}

5. 接口的高级特性

5.1 指针接收者 vs 值接收者

type Mover interface {
    Move()
}

// 值接收者实现
type Car struct{ model string }
func (c Car) Move() { 
    fmt.Println(c.model, "moving") 
}

// 指针接收者实现
type Bike struct{ model string }
func (b *Bike) Move() { 
    fmt.Println(b.model, "moving") 
}

func main() {
    var mover Mover
    
    car := Car{"Toyota"}
    mover = car     // ✓ 值可以赋值给接口
    mover = &car    // ✓ 指针也可以（会自动解引用）
    
    bike := Bike{"Giant"}
    // mover = bike     // ✗ 错误！Bike没有实现Mover
    mover = &bike       // ✓ 只有指针实现了接口
}

5.2 接口的零值

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

func main() {
    var w Writer
    fmt.Println(w == nil)  // true - 接口零值是nil
    
    var buf *bytes.Buffer  // buf是nil
    w = buf                // 接口不为nil，但动态值为nil
    
    fmt.Println(w == nil)  // false
    fmt.Printf("w类型: %T, 值: %v\n", w, w)  // *bytes.Buffer, <nil>
}

6. 实际应用模式

6.1 依赖注入

// 定义接口
type UserStore interface {
    Save(user User) error
    FindByID(id int) (User, error)
}

// 具体实现
type MySQLStore struct {
    db *sql.DB
}

func (m *MySQLStore) Save(user User) error {
    // 保存到MySQL
    return nil
}

func (m *MySQLStore) FindByID(id int) (User, error) {
    // 从MySQL查找
    return User{}, nil
}

// 服务层依赖接口
type UserService struct {
    store UserStore
}

func NewUserService(store UserStore) *UserService {
    return &UserService{store: store}
}

// 使用
func main() {
    // 生产环境用真实存储
    mysqlStore := &MySQLStore{db: realDB}
    service := NewUserService(mysqlStore)
    
    // 测试环境用模拟存储
    mockStore := &MockStore{}
    testService := NewUserService(mockStore)
}

6.2 插件架构

// 插件接口
type Plugin interface {
    Name() string
    Initialize() error
    Execute() error
}

// 注册插件
var plugins = make(map[string]Plugin)

func RegisterPlugin(p Plugin) {
    plugins[p.Name()] = p
}

// 不同插件实现
type LogPlugin struct{}
func (l *LogPlugin) Name() string { return "log" }
func (l *LogPlugin) Initialize() error { return nil }
func (l *LogPlugin) Execute() error { 
    fmt.Println("Logging...")
    return nil 
}

type AuthPlugin struct{}
func (a *AuthPlugin) Name() string { return "auth" }
func (a *AuthPlugin) Initialize() error { return nil }
func (a *AuthPlugin) Execute() error { 
    fmt.Println("Authenticating...")
    return nil 
}

func main() {
    // 注册插件
    RegisterPlugin(&LogPlugin{})
    RegisterPlugin(&AuthPlugin{})
    
    // 执行所有插件
    for _, plugin := range plugins {
        plugin.Execute()
    }
}

7. 接口实现检查技巧

7.1 编译时检查

// 技巧：声明一个变量来确保类型实现了接口
var _ Speaker = (*Dog)(nil)  // 编译时检查Dog是否实现Speaker
var _ Speaker = Dog{}        // 检查值类型

// 如果Dog没有实现Speaker，这里会编译错误

7.2 接口满足性检查

type MyInterface interface {
    Method1()
    Method2()
}

type MyType struct{}

func (m MyType) Method1() {}
// func (m MyType) Method2() {} // 注释掉这行会编译错误

// 检查是否实现
var _ MyInterface = MyType{}  // 编译错误：缺少Method2

总结

1. 隐式实现是Go接口的核心：类型自动实现接口，无需声明
2. 接口关注行为而非类型：只要方法匹配，类型即可使用
3. 小接口优于大接口：易于组合和实现
4. 空接口提供灵活性：可以处理任意类型
5. 接口实现检查发生在编译时：类型安全有保障
6. 实际应用广泛：多态、依赖注入、插件系统等

理解Go接口的关键是转变思维：不要问"这是什么类型"，要问"它能做什么"。只要一个类型有你需要的方法，它就可以被当作接口使用。