Go 结构体方法

如果说结构体 (Struct) 定义了数据的“骨架”，那么方法 (Methods) 就赋予了这些数据真正的“灵魂”与“行为”。

在 Go 语言中，方法其实就是一种作用于特定类型（通常是结构体）的特殊函数。虽然 Go 并没有传统意义上的 class (类) 关键字，但通过将方法与结构体绑定，Go 完美实现了面向对象编程 (OOP) 中的核心概念：封装与行为定义。

本章我们将深入探讨如何定义方法，彻底搞懂值接收者和指针接收者之间的关键区别，并在实战中灵活运用它们。

1. 定义方法 (Defining Methods)

在 Go 语言中，方法看起来和普通的函数几乎一模一样，唯一的区别在于：方法在 func 关键字和方法名之间，多了一个特殊的参数——接收者 (Receiver)。

这个接收者声明了该方法“隶属于”哪个具体的类型。

1.1 基础语法

func (接收者变量 接收者类型) 方法名(参数列表) (返回值列表) {
    // 方法体逻辑
}

1.2 示例：计算矩形面积

我们来定义一个 Rectangle 结构体，并为它绑定一个计算面积的 Area 方法：

package main

import "fmt"

type Rectangle struct {
    Width  float64
    Height float64
}

// Area 方法绑定到了 Rectangle 类型上
// 'r' 是接收者的变量名（类似其他语言中的 this 或 self，但在 Go 中通常用类型首字母的小写）
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func main() {
    rect := Rectangle{Width: 10, Height: 5}
    
    // 使用点号 (.) 来调用结构体实例上的方法
    area := rect.Area() 
    
    fmt.Println("矩形面积:", area) // 输出: 矩形面积: 50
}

2. 核心对决：值接收者 vs. 指针接收者

在定义方法时，你面临一个极其重要的选择：是将接收者定义为值 (Value) 还是 指针 (Pointer)？这直接决定了方法内部能否修改外部的原始结构体数据。

2.1 值接收者 (Value Receivers)

当你使用值接收者时，方法接收到的是调用者结构体的一个拷贝 (Copy)。在方法内部对接收者做的任何修改，都绝对不会影响外面的原始数据。

package main

import "fmt"

type Circle struct {
    Radius float64
}

// ⚠️ 这是一个【值接收者】方法
func (c Circle) Scale(factor float64) {
    c.Radius = c.Radius * factor // 这里修改的仅仅是 c 的复印件！
    fmt.Println("方法内部的半径:", c.Radius)
}

func main() {
    circle := Circle{Radius: 5}
    circle.Scale(2)
    
    // 原件依然是 5，没有被放大！
    fmt.Println("外部原始的半径:", circle.Radius) // 输出: 外部原始的半径: 5
}

2.2 指针接收者 (Pointer Receivers)

当你使用指针接收者时，方法接收到的是指向调用者结构体的内存地址指针。这意味着在方法内部的任何修改，都会直接改变外部的原始数据。

package main

import "fmt"

type Circle struct {
    Radius float64
}

// 这是一个【指针接收者】方法 (注意类型前面的 *)
func (c *Circle) Scale(factor float64) {
    c.Radius = c.Radius * factor // 顺着指针修改了原始数据
    fmt.Println("方法内部的半径:", c.Radius)
}

func main() {
    circle := Circle{Radius: 5}
    circle.Scale(2) // Go 会自动在底层将 circle 转为 &circle 传递进去
    
    // 原件被成功修改！
    fmt.Println("外部原始的半径:", circle.Radius) // 输出: 外部原始的半径: 10
}

3. 该选哪个？

为了让你的代码清晰且高效，请参考以下对照表来决定使用哪种接收者：

4. 实战案例演示

让我们看看在复杂业务中，方法是如何大显身手的。

4.1 案例 1：银行账户管理 (状态修改)

银行的存款和取款必然要修改账户余额，所以必须用指针接收者；而查询余额只需要读取，可以用值接收者。

package main

import (
    "fmt"
    "errors"
)

type BankAccount struct {
    AccountNumber string
    Balance       float64
}

// Deposit 存款：需要修改余额，使用【指针接收者】
func (account *BankAccount) Deposit(amount float64) {
    account.Balance += amount
}

// Withdraw 取款：需要修改余额，使用【指针接收者】，并返回错误信息
func (account *BankAccount) Withdraw(amount float64) error {
    if amount > account.Balance {
        return errors.New("余额不足")
    }
    account.Balance -= amount
    return nil
}

// GetBalance 查询：只需读取，使用【值接收者】即可
func (account BankAccount) GetBalance() float64 {
    return account.Balance
}

func main() {
    acc := BankAccount{AccountNumber: "622202", Balance: 1000}
    
    acc.Deposit(500)
    fmt.Println("存款后余额:", acc.GetBalance()) // 输出: 1500
    
    err := acc.Withdraw(2000)
    if err != nil {
        fmt.Println("取款失败:", err) // 输出: 取款失败: 余额不足
    }
}

4.2 案例 2：实现内建的 Stringer 接口 (定制打印格式)

Go 语言内置了一个非常著名的接口叫 Stringer。只要你给自己的结构体绑定一个签名名为 String() string 的方法，当你用 fmt.Println 打印这个结构体时，Go 就会自动调用你写的方法，输出你定制的格式。

package main

import "fmt"

type Point struct {
    X, Y int
}

// 实现 String() 方法来自定义打印输出
func (p Point) String() string {
    return fmt.Sprintf("坐标点位于: [%d, %d]", p.X, p.Y)
}

func main() {
    point := Point{X: 10, Y: 20}
    
    // fmt.Println 会自动检测并调用 point.String()
    fmt.Println(point) // 输出: 坐标点位于: [10, 20]
}