1.5.1 方法定义与使用 #

在 Go 语言中，方法是与特定类型关联的函数。通过方法，我们可以为自定义类型添加行为，实现面向对象编程的核心概念。本节将详细介绍方法的定义、使用以及相关的重要概念。

方法的基本概念 #

方法是一种特殊的函数，它有一个接收者（receiver）。接收者指定了该方法属于哪个类型。方法的语法格式如下：

func (receiver ReceiverType) MethodName(parameters) (returns) {
    // 方法体
}

基本方法定义示例 #

让我们从一个简单的例子开始：

package main

import "fmt"

// 定义一个结构体类型
type Rectangle struct {
    Width  float64
    Height float64
}

// 为 Rectangle 类型定义方法
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

func main() {
    rect := Rectangle{Width: 10, Height: 5}

    fmt.Printf("面积: %.2f\n", rect.Area())
    fmt.Printf("周长: %.2f\n", rect.Perimeter())
}

在这个例子中，我们为 Rectangle 类型定义了两个方法：Area() 和 Perimeter()。这些方法可以直接通过结构体实例调用。

值接收者与指针接收者 #

Go 语言中的方法接收者有两种类型：值接收者和指针接收者。理解它们的区别对于正确使用方法至关重要。

值接收者 #

值接收者会创建接收者的副本，方法内部对接收者的修改不会影响原始值：

package main

import "fmt"

type Counter struct {
    Value int
}

// 值接收者方法
func (c Counter) Increment() {
    c.Value++  // 这只会修改副本
}

func (c Counter) GetValue() int {
    return c.Value
}

func main() {
    counter := Counter{Value: 0}

    fmt.Printf("初始值: %d\n", counter.GetValue())

    counter.Increment()
    fmt.Printf("调用 Increment 后: %d\n", counter.GetValue()) // 仍然是 0
}

指针接收者 #

指针接收者接收的是指向原始值的指针，可以修改原始值：

package main

import "fmt"

type Counter struct {
    Value int
}

// 指针接收者方法
func (c *Counter) Increment() {
    c.Value++  // 修改原始值
}

func (c *Counter) Reset() {
    c.Value = 0
}

func (c Counter) GetValue() int {
    return c.Value
}

func main() {
    counter := Counter{Value: 0}

    fmt.Printf("初始值: %d\n", counter.GetValue())

    counter.Increment()
    fmt.Printf("调用 Increment 后: %d\n", counter.GetValue()) // 现在是 1

    counter.Increment()
    counter.Increment()
    fmt.Printf("再次调用后: %d\n", counter.GetValue()) // 现在是 3

    counter.Reset()
    fmt.Printf("重置后: %d\n", counter.GetValue()) // 现在是 0
}

选择接收者类型的原则 #

选择值接收者还是指针接收者需要考虑以下因素：

需要修改接收者：如果方法需要修改接收者，必须使用指针接收者
性能考虑：对于大型结构体，指针接收者避免了复制开销
一致性：如果类型的某些方法使用指针接收者，建议所有方法都使用指针接收者

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

// 指针接收者 - 修改数据
func (p *Person) SetAge(age int) {
    p.Age = age
}

// 指针接收者 - 保持一致性
func (p *Person) GetInfo() string {
    return fmt.Sprintf("姓名: %s, 年龄: %d", p.Name, p.Age)
}

// 指针接收者 - 修改数据
func (p *Person) HaveBirthday() {
    p.Age++
    fmt.Printf("%s 过生日了！现在 %d 岁\n", p.Name, p.Age)
}

func main() {
    person := Person{Name: "张三", Age: 25}

    fmt.Println(person.GetInfo())

    person.SetAge(30)
    fmt.Println(person.GetInfo())

    person.HaveBirthday()
    fmt.Println(person.GetInfo())
}

方法与函数的区别 #

虽然方法和函数在语法上相似，但它们有重要的区别：

调用方式不同 #

package main

import "fmt"

type Circle struct {
    Radius float64
}

// 方法
func (c Circle) Area() float64 {
    return 3.14159 * c.Radius * c.Radius
}

// 函数
func CircleArea(c Circle) float64 {
    return 3.14159 * c.Radius * c.Radius
}

func main() {
    circle := Circle{Radius: 5}

    // 方法调用
    fmt.Printf("方法调用结果: %.2f\n", circle.Area())

    // 函数调用
    fmt.Printf("函数调用结果: %.2f\n", CircleArea(circle))
}

方法可以被继承和重写 #

通过嵌入类型，方法可以被"继承"：

package main

import "fmt"

type Animal struct {
    Name string
}

func (a Animal) Speak() {
    fmt.Printf("%s 发出声音\n", a.Name)
}

type Dog struct {
    Animal  // 嵌入 Animal
    Breed string
}

// Dog 可以重写 Animal 的方法
func (d Dog) Speak() {
    fmt.Printf("%s 汪汪叫\n", d.Name)
}

func (d Dog) GetBreed() string {
    return d.Breed
}

func main() {
    dog := Dog{
        Animal: Animal{Name: "旺财"},
        Breed:  "金毛",
    }

    dog.Speak()  // 调用 Dog 的 Speak 方法
    fmt.Printf("品种: %s\n", dog.GetBreed())
}

方法集 #

每个类型都有一个方法集，它决定了该类型可以调用哪些方法。理解方法集对于接口的实现非常重要。

值类型和指针类型的方法集 #

package main

import "fmt"

type MyType struct {
    Value int
}

// 值接收者方法
func (m MyType) ValueMethod() {
    fmt.Println("值接收者方法")
}

// 指针接收者方法
func (m *MyType) PointerMethod() {
    fmt.Println("指针接收者方法")
}

func main() {
    var t MyType = MyType{Value: 42}
    var p *MyType = &MyType{Value: 42}

    // 值类型可以调用值接收者和指针接收者方法
    t.ValueMethod()
    t.PointerMethod()  // Go 会自动转换为 (&t).PointerMethod()

    // 指针类型也可以调用值接收者和指针接收者方法
    p.ValueMethod()    // Go 会自动转换为 (*p).ValueMethod()
    p.PointerMethod()
}

实际应用示例 #

让我们通过一个更复杂的例子来展示方法的实际应用：

package main

import (
    "fmt"
    "math"
)

// 银行账户结构体
type BankAccount struct {
    AccountNumber string
    HolderName    string
    Balance       float64
}

// 创建新账户
func NewBankAccount(accountNumber, holderName string, initialBalance float64) *BankAccount {
    return &BankAccount{
        AccountNumber: accountNumber,
        HolderName:    holderName,
        Balance:       initialBalance,
    }
}

// 存款方法
func (ba *BankAccount) Deposit(amount float64) error {
    if amount <= 0 {
        return fmt.Errorf("存款金额必须大于0")
    }
    ba.Balance += amount
    fmt.Printf("存款成功！存入 %.2f 元，当前余额: %.2f 元\n", amount, ba.Balance)
    return nil
}

// 取款方法
func (ba *BankAccount) Withdraw(amount float64) error {
    if amount <= 0 {
        return fmt.Errorf("取款金额必须大于0")
    }
    if amount > ba.Balance {
        return fmt.Errorf("余额不足，当前余额: %.2f 元", ba.Balance)
    }
    ba.Balance -= amount
    fmt.Printf("取款成功！取出 %.2f 元，当前余额: %.2f 元\n", amount, ba.Balance)
    return nil
}

// 查询余额方法
func (ba BankAccount) GetBalance() float64 {
    return ba.Balance
}

// 获取账户信息方法
func (ba BankAccount) GetAccountInfo() string {
    return fmt.Sprintf("账户号: %s, 持有人: %s, 余额: %.2f 元",
        ba.AccountNumber, ba.HolderName, ba.Balance)
}

// 转账方法
func (ba *BankAccount) Transfer(to *BankAccount, amount float64) error {
    if amount <= 0 {
        return fmt.Errorf("转账金额必须大于0")
    }
    if amount > ba.Balance {
        return fmt.Errorf("余额不足，无法转账")
    }

    ba.Balance -= amount
    to.Balance += amount

    fmt.Printf("转账成功！从 %s 向 %s 转账 %.2f 元\n",
        ba.HolderName, to.HolderName, amount)
    return nil
}

// 计算利息方法（年利率）
func (ba *BankAccount) CalculateInterest(rate float64) float64 {
    return ba.Balance * rate / 100
}

// 应用利息方法
func (ba *BankAccount) ApplyInterest(rate float64) {
    interest := ba.CalculateInterest(rate)
    ba.Balance += interest
    fmt.Printf("利息已结算！利率: %.2f%%, 利息: %.2f 元，当前余额: %.2f 元\n",
        rate, interest, ba.Balance)
}

func main() {
    // 创建两个银行账户
    account1 := NewBankAccount("001", "张三", 1000.0)
    account2 := NewBankAccount("002", "李四", 500.0)

    // 显示初始账户信息
    fmt.Println("=== 初始账户信息 ===")
    fmt.Println(account1.GetAccountInfo())
    fmt.Println(account2.GetAccountInfo())
    fmt.Println()

    // 存款操作
    fmt.Println("=== 存款操作 ===")
    account1.Deposit(200)
    account2.Deposit(300)
    fmt.Println()

    // 取款操作
    fmt.Println("=== 取款操作 ===")
    account1.Withdraw(150)
    err := account2.Withdraw(1000) // 余额不足
    if err != nil {
        fmt.Printf("取款失败: %v\n", err)
    }
    fmt.Println()

    // 转账操作
    fmt.Println("=== 转账操作 ===")
    account1.Transfer(account2, 100)
    fmt.Println()

    // 利息计算和应用
    fmt.Println("=== 利息结算 ===")
    account1.ApplyInterest(2.5) // 2.5% 年利率
    account2.ApplyInterest(2.5)
    fmt.Println()

    // 最终账户信息
    fmt.Println("=== 最终账户信息 ===")
    fmt.Println(account1.GetAccountInfo())
    fmt.Println(account2.GetAccountInfo())
}

方法的高级特性 #

方法表达式 #

Go 语言允许将方法作为值来使用：

package main

import "fmt"

type Calculator struct {
    Value float64
}

func (c *Calculator) Add(x float64) {
    c.Value += x
}

func (c *Calculator) Multiply(x float64) {
    c.Value *= x
}

func main() {
    calc := &Calculator{Value: 10}

    // 方法表达式
    addMethod := (*Calculator).Add
    multiplyMethod := (*Calculator).Multiply

    addMethod(calc, 5)
    fmt.Printf("加法后: %.2f\n", calc.Value)

    multiplyMethod(calc, 2)
    fmt.Printf("乘法后: %.2f\n", calc.Value)
}

方法值 #

也可以将绑定到特定接收者的方法作为值：

package main

import "fmt"

type Printer struct {
    Prefix string
}

func (p Printer) Print(message string) {
    fmt.Printf("%s: %s\n", p.Prefix, message)
}

func main() {
    printer := Printer{Prefix: "INFO"}

    // 方法值
    printFunc := printer.Print

    printFunc("这是一条消息")
    printFunc("这是另一条消息")
}

最佳实践 #

一致性原则：如果类型的任何方法需要指针接收者，建议所有方法都使用指针接收者
性能考虑：对于大型结构体，优先使用指针接收者
语义清晰：方法名应该清楚地表达其功能
错误处理：方法应该适当地处理和返回错误
文档注释：为公开的方法添加适当的文档注释

小结 #

本节介绍了 Go 语言中方法的定义和使用，包括：

方法的基本语法和概念
值接收者与指针接收者的区别和选择原则
方法与函数的区别
方法集的概念
方法的高级特性和实际应用

理解方法是掌握 Go 语言面向对象编程的基础，它为我们后续学习接口和多态性奠定了重要基础。在下一节中，我们将学习 Go 语言的接口机制。