Go 的 interface 是其类型系统中最强大的特性之一。与 Java、C++ 等语言的显式接口声明不同，Go 使用隐式实现——只要类型实现了接口的所有方法，就自动满足该接口，无需显式声明。
Interface 基础
package main
import (
"fmt"
"math"
)
// 定义接口
type Shape interface {
Area() float64
Perimeter() float64
}
// 圆形
type Circle struct {
Radius float64
}
func (c Circle) Area() float64 {
return math.Pi * c.Radius * c.Radius
}
func (c Circle) Perimeter() float64 {
return 2 * math.Pi * c.Radius
}
// 矩形
type Rectangle struct {
Width, Height float64
}
func (r Rectangle) Area() float64 {
return r.Width * r.Height
}
func (r Rectangle) Perimeter() float64 {
return 2 * (r.Width + r.Height)
}
// 接受接口的函数
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 _, s := range shapes {
printShapeInfo(s)
}
}Interface 的底层结构
Go interface 在运行时由两个指针组成：
type：指向类型信息（方法表等）data：指向实际数据
// interface 内部结构（简化）
type iface struct {
tab *itab // 类型信息 + 方法表
data unsafe.Pointer // 指向实际数据
}这解释了为什么 interface 比较时需要 type 和 data 都相等：
var err error
var p *os.PathError = nil
fmt.Println(err == nil) // true：err 的 type 和 data 都是 nil
err = p
fmt.Println(err == nil) // false！err 的 type 不为 nil（是 *os.PathError）类型断言与类型开关
func describe(i interface{}) string {
switch v := i.(type) {
case int:
return fmt.Sprintf("int: %d", v)
case string:
return fmt.Sprintf("string: %q", v)
case []int:
return fmt.Sprintf("[]int with %d elements", len(v))
case Shape:
return fmt.Sprintf("Shape with area %.2f", v.Area())
default:
return fmt.Sprintf("unknown type: %T", v)
}
}安全的类型断言（避免 panic）：
var s Shape = Circle{Radius: 3}
// 安全断言
if c, ok := s.(Circle); ok {
fmt.Println("Circle radius:", c.Radius)
}
// 不安全断言（类型不匹配会 panic）
// r := s.(Rectangle) // panic!接口组合
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
}
// 更复杂的组合
type ReadWriteCloser interface {
Reader
Writer
Close() error
}设计最佳实践
1. 接口尽量小
// 好：小接口更灵活
type Stringer interface {
String() string
}
// 避免：大接口限制了实现者
type Everything interface {
String() string
Read([]byte) (int, error)
Write([]byte) (int, error)
Close() error
// ...
}2. 在使用方定义接口，而非提供方
// 提供方：只定义结构体和方法
// service/user.go
type UserService struct{}
func (s *UserService) GetUser(id int) (*User, error) { ... }
func (s *UserService) CreateUser(u *User) error { ... }
// 使用方：根据需要定义接口
// handler/user.go
type userGetter interface {
GetUser(id int) (*User, error)
}
// handler 只依赖它需要的接口
type UserHandler struct {
svc userGetter
}3. 空接口谨慎使用
// 避免过度使用 interface{}（现在是 any）
func process(data interface{}) { // 丢失类型信息
// 需要大量类型断言
}
// 更好：使用泛型（Go 1.18+）
func process[T any](data T) {
// 保留类型信息
}4. 使用接口实现依赖注入
type Logger interface {
Info(msg string)
Error(msg string, err error)
}
type UserService struct {
repo UserRepository
logger Logger
cache Cache
}
// 测试时可以注入 mock 实现
func NewUserService(repo UserRepository, logger Logger, cache Cache) *UserService {
return &UserService{repo: repo, logger: logger, cache: cache}
}常见错误
返回接口而非具体类型：
// 不推荐：限制了调用者获取具体类型信息的能力
func NewBuffer() io.Writer {
return &bytes.Buffer{}
}
// 推荐：返回具体类型，让调用者决定是否用接口接收
func NewBuffer() *bytes.Buffer {
return &bytes.Buffer{}
}接收者类型不一致：
type Animal interface {
Speak() string
}
type Dog struct{}
// 值接收者：Dog 和 *Dog 都实现了 Animal
func (d Dog) Speak() string { return "Woof!" }
type Cat struct{}
// 指针接收者：只有 *Cat 实现了 Animal，Cat 没有
func (c *Cat) Speak() string { return "Meow!" }
var a Animal = Dog{} // OK
var b Animal = &Dog{} // OK
var c Animal = Cat{} // 编译错误！
var d Animal = &Cat{} // OK总结
Go interface 的设计哲学体现在：
- 隐式实现：解耦接口定义和实现，更灵活
- 小接口：符合”单一职责”原则，组合优于继承
- 接口在使用方定义：避免循环依赖，保持包的独立性
- nil interface 陷阱：理解 type 和 data 两个字段才能避免坑
interface 是 Go 实现多态、依赖倒置的核心机制，合理使用可以大幅提高代码的可测试性和可维护性。