9.1 Go Interface 基础知识学习笔记

Go Interface 基础知识学习笔记

1. 接口的定义

接口是一组方法签名的集合，定义了"行为"但不实现：

type Shape interface {
    Area() float64
}

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

要点：

• 接口只声明方法签名，没有实现代码
• 任何类型只要实现了接口的所有方法，就自动满足该接口，不需要显式声明
• 这叫做隐式实现 （duck typing），Go 不像 Java 需要 implements 关键字

---

2. 实现接口

Rectangle 和 Circle 都实现了 Area() float64 方法，因此它们都自动满足 Shape 接口：

type Rectangle struct {
    Width  float64
    Height float64
}

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

type Circle struct {
    Radius float64
}

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

同样，Writer 接口定义如下：

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

FileWriter 和 ConsoleWriter 都实现了 Write([]byte) (int, error) 方法，自动满足 Writer 接口：

type FileWriter struct {
    Filename string
}

func (fw FileWriter) Write(data []byte) (int, error) {
    fmt.Printf("Writing %d bytes to file: %s\n", len(data), fw.Filename)
    fmt.Printf("Content: %s\n", string(data))
    return len(data), nil
}

type ConsoleWriter struct{}

func (cw ConsoleWriter) Write(data []byte) (int, error) {
    fmt.Printf("Console: %s", string(data))
    return len(data), nil
}

要点 ：没有 implements、extends 等关键字。只要方法签名完全匹配（方法名、参数类型、返回值类型），就自动实现接口。

---

3. 接口作为函数参数 --- 多态

函数接收接口类型参数时，可以传入任何实现了该接口的类型：

func printShapeInfo(s Shape) {
    fmt.Printf("Shape area: %.2f\n", s.Area())
}

func writeMessage(w Writer, message string) {
    w.Write([]byte(message))
}

不同类型传入同一个函数，表现出不同行为（多态）：

rect := Rectangle{Width: 5, Height: 3}
circle := Circle{Radius: 4}

printShapeInfo(rect)    // 输出: Shape area: 15.00
printShapeInfo(circle)  // 输出: Shape area: 50.27

fileWriter := FileWriter{Filename: "output.txt"}
consoleWriter := ConsoleWriter{}

writeMessage(fileWriter, "Hello, File!")
// 输出: Writing 12 bytes to file: output.txt
//       Content: Hello, File!

writeMessage(consoleWriter, "Hello, Console!")
// 输出: Console: Hello, Console!

要点 ：函数不在乎传入的具体类型，只在乎它是否实现了接口要求的方法。这就是多态------同一接口，不同实现，不同行为。

---

4. 接口切片 --- 存储不同类型

接口类型的切片可以存储所有实现了该接口的不同类型：

shapes := []Shape{rect, circle}

var totalArea float64
for _, shape := range shapes {
    totalArea += shape.Area()
}
fmt.Printf("Total area of all shapes: %.2f\n", totalArea)
// 输出: Total area of all shapes: 65.27

writers := []Writer{fileWriter, consoleWriter}

for i, writer := range writers {
    message := fmt.Sprintf("Message %d from writer\n", i+1)
    writeMessage(writer, message)
}
// 输出: Writing 22 bytes to file: output.txt / Content: Message 1 from writer
//       Console: Message 2 from writer

要点 ：[]Shape 可以同时存放 Rectangle 和 Circle，[]Writer 可以同时存放 FileWriter 和 ConsoleWriter。这在没有接口的语言中是无法实现的（数组/切片要求所有元素类型相同）。

---

5. 接口赋值

接口变量可以动态切换底层类型：

var shape Shape

shape = rect    // Rectangle 实现了 Shape
fmt.Printf("Shape (Rectangle) area: %.2f\n", shape.Area())  // 15.00

shape = circle  // Circle 也实现了 Shape
fmt.Printf("Shape (Circle) area: %.2f\n", shape.Area())     // 50.27

要点：接口变量内部存储了两部分信息：

1. 类型信息 --- 底层是什么类型（Rectangle 还是 Circle）
2. 值信息 --- 底层类型的实际数据

同一个 shape 变量可以先后指向不同类型的值，调用 shape.Area() 时，Go 根据 shape 当前的底层类型选择对应的方法实现。

---

知识点总结

知识点	关键概念
接口定义	type Name interface { 方法签名 }，只声明不实现
隐式实现	不需要 implements，方法签名匹配即自动实现接口
多态	函数接收接口参数，不同类型表现出不同行为
接口切片	[]Shape 可存放不同类型，统一遍历调用
接口赋值	同一个接口变量可动态切换底层类型
接口内部	存储 (类型, 值) 两部分信息，调用时根据类型选择方法