Go语言从入门到进阶：8. 接口

Go 语言接口（Interface）详解

Go 语言的接口（interface） 是核心特性之一，它是一种约定型类型，只定义方法签名（方法名、参数、返回值），不实现方法逻辑，也不包含字段。

它的核心作用：解耦代码、实现多态、让程序更灵活 。Go 的接口是隐式实现 ，不需要像 Java 那样显式写 implements。

---

一、基础概念

1. 什么是接口？

接口是一组方法的集合 ，任何类型只要实现了接口里的所有方法 ，就自动实现了这个接口，无需显式声明。

2. 核心特点

1. 隐式实现：类型和接口无耦合关系
2. 无状态、无字段：只定义行为，不存储数据
3. 多态：同一个接口可以接收不同的实现类型
4. 空接口 ：可以表示任意类型

---

二、快速入门示例

1. 定义接口

// 定义一个接口
type Animal interface {
    Speak() string // 只定义方法，不实现
}

2. 实现接口（隐式）

// 定义结构体 Dog
type Dog struct{}

// Dog 实现 Speak 方法 → 自动实现 Animal 接口
func (d Dog) Speak() string {
    return "汪汪汪"
}

// 定义结构体 Cat
type Cat struct{}

// Cat 实现 Speak 方法 → 自动实现 Animal 接口
func (c Cat) Speak() string {
    return "喵喵喵"
}

3. 使用接口（多态）

package main

import "fmt"

type Animal interface {
	Speak() string
}

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

type Cat struct{}
func (c Cat) Speak() string { return "喵喵喵" }

// 接收 Animal 接口，任意实现类都可以传入
func MakeSound(a Animal) {
	fmt.Println(a.Speak())
}

func main() {
	d := Dog{}
	c := Cat{}

	MakeSound(d) // 输出：汪汪汪
	MakeSound(c) // 输出：喵喵喵
}

这就是多态：同一个函数，处理不同类型的对象，表现出不同行为。

---

三、接口的两种定义形式

1. 普通接口（有方法）

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

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

2. 空接口 interface{}

没有任何方法的接口 ，可以表示所有类型（int、string、struct、slice 等）。

// 可以接收任意类型参数
func PrintAny(v interface{}) {
    fmt.Println(v)
}

使用场景：函数需要接收任意类型参数时（类似 Java 的 Object）。

空接口不提供类型安全，尽量使用具体类型或泛型（Go 1.18+）

---

四、接口嵌套

Go 支持接口组合，把多个接口合并成一个：

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
}

只要类型同时实现 Read 和 Write，就实现了 ReadWriter。

---

五、接口值（底层原理）

一个接口变量实际包含两部分：

1. 类型（Type）：具体实现的类型
2. 值（Value）：具体类型的实例

var a Animal
a = Dog{}

// a 的类型是 main.Dog，值是 {}
fmt.Printf("类型：%T，值：%v\n", a, a)

---

六、类型断言（获取接口里的具体值）

接口是抽象的，想转回原来的具体类型，用类型断言：

语法

// 安全写法（推荐）
value, ok := 接口变量.(具体类型)

示例

func CheckAnimal(a Animal) {
	// 尝试转回 Dog 类型
	dog, ok := a.(Dog)
	if ok {
		fmt.Println("是狗狗：", dog.Speak())
		return
	}

	// 尝试转回 Cat 类型
	cat, ok := a.(Cat)
	if ok {
		fmt.Println("是猫咪：", cat.Speak())
	}
}

switch 批量判断类型

func GetType(a interface{}) {
	switch v := a.(type) {
	case int:
		fmt.Println("int 类型：", v)
	case string:
		fmt.Println("string 类型：", v)
	case Dog:
		fmt.Println("Dog 类型")
	default:
		fmt.Printf("未知类型：%T\n", v)
	}
}

---

七、指针接收者 vs 值接收者

实现接口时，接收者类型会影响接口赋值：

1. 值接收者

func (d Dog) Speak() string {}

• Dog{} 和 &Dog{} 都可以赋值给接口

2. 指针接收者

func (d *Dog) Speak() string {}

• 只有 &Dog{} 可以赋值给接口
• Dog{} 不可以（编译器报错）

---

八、常见使用场景

1. 解耦：业务逻辑不依赖具体实现，只依赖接口
2. 多态：统一处理不同类型对象
3. 通用函数：空接口接收任意类型
4. 标准库 ：io.Reader、io.Writer、error 都是接口

1. 小而专一的接口（接口隔离原则）

// 好的设计：小而专注
type Reader interface {
    Read([]byte) (int, error)
}

type Closer interface {
    Close() error
}

// 避免大而全的接口
type BadInterface interface {
    Read([]byte) (int, error)
    Write([]byte) (int, error)
    Close() error
    Seek(int64, int) (int64, error)
}

2. 接受接口，返回具体类型

// 函数参数接受接口
func Process(r io.Reader) error {
    // ...
}

// 函数返回具体类型
func NewFile(name string) *File {
    return &File{name: name}
}

3. 标准库常用接口

// fmt.Stringer - 字符串表示
type Stringer interface {
    String() string
}

// error - 错误处理
type error interface {
    Error() string
}

// io.Reader/io.Writer - I/O 操作
type Reader interface {
    Read(p []byte) (n int, err error)
}

---

九、总结

1. 接口 = 方法集合，定义行为，不实现行为
2. 隐式实现：实现所有方法 = 自动实现接口
3. 空接口 ：interface{} 表示任意类型
4. 多态：同一接口接收不同实现类型
5. 类型断言：把接口转回具体类型
6. 指针/值接收者：影响接口赋值规则

---

关键点回顾

• Go 接口是行为的抽象，不是数据的抽象
• 实现无侵入，代码更灵活
• 核心价值：解耦 + 多态
• 空接口是 Go 中实现"泛型"的基础（Go 1.18+ 支持正式泛型）