第六章 方法 (Methods)
一、导读
1.1 本章学习目标
掌握 Go 方法（Method）的定义方式，理解接收者（Receiver）的概念
区分值接收者和指针接收者的语义差异
理解 Go 的方法集（Method Set）规则及其对接口满足的影响
掌握方法链（Method Chaining）的实现方式
理解 Go 的组合（Composition）模式如何替代继承
掌握 String() 方法实现 fmt.Stringer 接口
理解方法表达式（Method Expression）和方法值（Method Value）
能够设计符合 Go 惯用法的类型和方法
1.2 为什么本章如此重要
方法是 Go 实现面向对象编程的核心机制。与 Java/C++ 将方法绑定在类上不同，Go 的方法是"附加"在类型上的——你可以在任何自定义类型上定义方法（但不能在基础类型上定义）。这种设计保持了语言的简洁性，同时提供了足够的表达能力。
值接收者与指针接收者的选择是 Go 编程中最重要的设计决策之一。值接收者操作的是类型的副本，不影响原始数据；指针接收者操作的是原始数据，可以修改类型的状态。这个选择不仅影响方法的行为，还决定了类型是否满足某个接口——值类型的方法集只包含值接收者方法，而指针类型的方法集包含所有方法。
Go 通过组合（Embedding）替代继承，实现了代码复用。与继承的"is-a"关系不同，组合表达的是"has-a"关系，更加灵活且避免了继承层次过深带来的复杂性。理解组合模式是编写地道 Go 代码的关键。
1.3 核心问题引导
值接收者和指针接收者在什么场景下应该选择哪个？
为什么 String() 方法通常使用值接收者，而 Scan() 方法使用指针接收者？
Go 的方法集规则是什么？为什么 *T 的方法集包含 T 的方法？
组合与继承有什么本质区别？组合如何避免"大猩猩与香蕉"问题？
方法表达式 T.Method 和方法值 t.Method 有什么区别？
如何实现方法链（Builder 模式）？需要注意什么？
二、核心概念详解
6.1 方法定义
方法通过接收者（Receiver）与类型关联：
type Rectangle struct {
Width, Height float64
}
// 值接收者
func (r Rectangle) Area() float64 {
return r.Width * r.Height
}
// 指针接收者
func (r *Rectangle) Scale(factor float64) {
r.Width *= factor
r.Height *= factor
}
func main() {
r := Rectangle{Width: 10, Height: 5}
fmt.Println(r.Area()) // 50
r.Scale(2) // Go 自动取地址：(&r).Scale(2)
fmt.Println(r.Area()) // 200
}值接收者 vs 指针接收者：
| 特征 | 值接收者 | 指针接收者 |
|---|---|---|
| 修改原始数据 | 不能 | 能 |
| 复制开销 | 复制整个值 | 只复制指针 |
| 并发安全 | 天然安全 | 需要同步 |
| 方法集 | 只包含值方法 | 包含所有方法 |
选择原则：
- 需要修改接收者 → 指针接收者
- 接收者较大（如包含多个字段的结构体） → 指针接收者（避免复制）
- 接收者包含切片、Map 等引用类型 → 值接收者也可以（引用共享）
- 一致性：同一类型的方法应该统一使用值或指针接收者
6.2 方法集规则
方法集决定了类型是否满足接口：
T的方法集：只包含值接收者方法*T的方法集：包含值接收者和指针接收者的所有方法
type Reader interface {
Read(p []byte) (int, error)
}
type MyReader struct{}
func (m *MyReader) Read(p []byte) (int, error) {
// 实现
return 0, nil
}
var r1 Reader = &MyReader{} // 正确：*MyReader 有 Read 方法
// var r2 Reader = MyReader{} // 编译错误：MyReader 没有 Read 方法6.3 组合替代继承
Go 通过结构体嵌入实现组合，替代了传统面向对象语言的继承。
type Base struct {
Name string
}
func (b Base) Describe() string {
return fmt.Sprintf("Name: %s", b.Name)
}
type Derived struct {
Base // 嵌入
Extra string
}
func (d Derived) Describe() string {
return fmt.Sprintf("%s, Extra: %s", d.Base.Describe(), d.Extra)
}
func main() {
d := Derived{Base: Base{Name: "Test"}, Extra: "Info"}
fmt.Println(d.Describe()) // 调用 Derived 的方法
fmt.Println(d.Base.Describe()) // 调用 Base 的方法
fmt.Println(d.Name) // 提升字段
}6.4 Stringer 接口
实现 fmt.Stringer 接口可以自定义类型的打印格式：
type IP struct {
A, B, C, D byte
}
func (ip IP) String() string {
return fmt.Sprintf("%d.%d.%d.%d", ip.A, ip.B, ip.C, ip.D)
}
func main() {
ip := IP{192, 168, 1, 1}
fmt.Println(ip) // 192.168.1.1（自动调用 String()）
}6.5 方法表达式与方法值
type Point struct{ X, Y float64 }
func (p Point) Distance() float64 {
return math.Sqrt(p.X*p.X + p.Y*p.Y)
}
// 方法表达式：类型.方法名，是一个函数
distanceFunc := Point.Distance
p := Point{3, 4}
fmt.Println(distanceFunc(p)) // 5
// 方法值：实例.方法名，绑定了接收者
pDistance := p.Distance
fmt.Println(pDistance()) // 5三、深入分析与讨论
3.1 接收者选择的设计准则
Go 社区对于接收者选择有明确的共识：如果有任何疑问，使用指针接收者。这是因为指针接收者总是可以工作的，而值接收者在需要修改状态或类型较大时会导致问题。
标准库中的惯例是：String()、Error() 等只读方法使用值接收者；Scan()、Unmarshal() 等需要修改状态的方法使用指针接收者。sync.Mutex 等需要同步的类型必须使用指针接收者（复制锁是错误的）。
3.2 组合 vs 继承的哲学差异
继承表达的是"is-a"关系（正方形是一个矩形），组合表达的是"has-a"关系（汽车有引擎）。Go 选择组合是因为它更灵活：你可以自由选择组合哪些类型，而不受继承层次的限制。当需要"重写"行为时，通过嵌入和同名方法实现，而不是通过虚函数表。
3.3 方法链与 Builder 模式
方法链通过让方法返回接收者自身来实现：
type Builder struct {
buf bytes.Buffer
}
func (b *Builder) WriteString(s string) *Builder {
b.buf.WriteString(s)
return b
}
result := new(Builder).
WriteString("Hello").
WriteString(", ").
WriteString("World!").
buf.String()四、实践案例
4.1 时间序列数据结构
使用方法和组合实现一个带统计功能的数据集合。
package main
import (
"fmt"
"math"
"sort"
)
type Numbers []float64
func (n Numbers) Sum() float64 {
total := 0.0
for _, v := range n {
total += v
}
return total
}
func (n Numbers) Mean() float64 {
if len(n) == 0 {
return 0
}
return n.Sum() / float64(len(n))
}
func (n Numbers) StdDev() float64 {
mean := n.Mean()
sum := 0.0
for _, v := range n {
diff := v - mean
sum += diff * diff
}
return math.Sqrt(sum / float64(len(n)))
}
func (n Numbers) Sorted() Numbers {
result := make(Numbers, len(n))
copy(result, n)
sort.Float64s(result)
return result
}
func (n Numbers) String() string {
return fmt.Sprintf("%v (len=%d)", []float64(n), len(n))
}
func main() {
data := Numbers{3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0, 6.0}
fmt.Println("数据:", data)
fmt.Printf("总和: %.1f\n", data.Sum())
fmt.Printf("均值: %.1f\n", data.Mean())
fmt.Printf("标准差: %.2f\n", data.StdDev())
fmt.Println("排序:", data.Sorted())
}4.2 组合模式实现 HTTP Handler
package main
import (
"fmt"
"net/http"
)
type Router struct {
routes map[string]http.Handler
}
func NewRouter() *Router {
return &Router{routes: make(map[string]http.Handler)}
}
func (r *Router) Handle(path string, handler http.Handler) {
r.routes[path] = handler
}
func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if handler, ok := r.routes[req.URL.Path]; ok {
handler.ServeHTTP(w, req)
return
}
http.NotFound(w, req)
}
func main() {
router := NewRouter()
router.Handle("/hello", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, "Hello!")
}))
router.Handle("/health", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, "OK")
}))
fmt.Println("Router ready")
}五、常见误区与注意事项
值接收者无法修改原始数据：如果方法需要修改结构体字段，必须使用指针接收者。值接收者的修改只影响副本。
混用值接收者和指针接收者：同一类型的方法应统一使用值或指针接收者。混用会导致接口满足的不一致。
复制包含 Mutex 的结构体：sync.Mutex 不能复制。包含 Mutex 的结构体必须使用指针接收者。
组合的方法歧义：如果嵌入的多个类型有同名方法，必须显式指定调用哪个：d.TypeA.Method()。
方法表达式的性能：方法表达式和方法值在底层通过闭包实现，有微小的开销。在性能敏感的代码中应注意。
六、本章小结
本章系统讲解了 Go 的方法系统。方法通过接收者与类型关联，值接收者操作副本，指针接收者操作原始数据。方法集规则决定了类型是否满足接口。Go 通过组合（嵌入）替代继承，实现灵活的代码复用。Stringer 接口提供了自定义打印格式的能力。方法表达式和方法值提供了函数式操作方法的途径。
七、思考题与练习
为 Matrix 类型实现 Add、Multiply 和 Transpose 方法。
解释为什么 bytes.Buffer 的方法使用指针接收者，而 time.Time 的方法使用值接收者。
使用组合实现一个 Logger 类型，嵌入 io.Writer，在每次写入前添加时间戳。
实现一个 Stack 类型，支持 Push、Pop、Peek 和 Size 方法。使用指针接收者。
实现 fmt.Stringer 接口为一个自定义的 Color 类型（RGB 格式）。
使用方法链实现一个 QueryBuilder，支持 Select、From、Where 和 Build 方法。
解释以下代码为什么不能编译：
type T struct{ x int }
func (t T) Set(v int) { t.x = v }
var t T
t.Set(5)
fmt.Println(t.x) // 输出什么？使用方法和组合实现一个简单的 ORM 模型基类，支持 TableName() 和 Fields() 方法。