一、Go 方法
Go 中的方法（Method） 是「绑定到特定类型的函数」，可以把它理解为：给自定义类型（结构体 / 基本类型）"新增" 的专属函数，核心作用是让代码更符合面向对象的 "封装" 思想，同时保持 Go 语言的简洁性。
1. 方法与函数的核心区别
| 特性 | 函数（Function） | 方法（Method） |
|---|---|---|
| 绑定关系 | 无绑定，属于全局 / 包级别 | 绑定到特定类型（接收者），属于该类型 |
| 定义语法 | func 函数名(参数) 返回值 {} | func (接收者) 方法名(参数) 返回值 {} |
| 调用方式 | 函数名(参数) | 实例.方法名(参数) |
2. 方法示例
package main import "fmt" // 1. 定义自定义类型（以结构体为例） type Person struct { Name string Age int } // 2. 为 Person 类型定义方法（值接收者） // (p Person) 是接收者：表示该方法绑定到 Person 类型 func (p Person) SayHello() { fmt.Printf("大家好，我是%s，今年%d岁\n", p.Name, p.Age) } // 3. 为 Person 定义修改属性的方法（指针接收者） func (p *Person) Grow() { p.Age++ // 修改接收者的属性 } func main() { // 4. 创建实例并调用方法 p := Person{Name: "张三", Age: 20} p.SayHello() // 输出：大家好，我是张三，今年20岁 p.Grow() // 调用指针接收者方法，修改Age p.SayHello() // 输出：大家好，我是张三，今年21岁 }
关键拆解：
- 接收者（Receiver） ：方法定义中 (p Person) 或 (p *Person) 是核心，p 是接收者变量（可自定义命名，通常用类型首字母小写），Person/*Person 是接收者类型；
- 调用逻辑：方法必须通过「类型实例」调用，不能像函数一样直接调用；
- 核心价值：把 "数据（结构体）" 和 "操作数据的逻辑（方法）" 绑定，实现封装。
3. 接收者的两种类型（值接收者 vs 指针接收者）
这是 Go 方法最核心的知识点，直接决定方法能否修改原实例：
| 接收者类型 | 语法示例 | 本质 | 能否修改原实例 | 适用场景 |
|---|---|---|---|---|
| 值接收者 | (p Person) | 接收实例的拷贝 | 不能 | 只读操作、简单类型、避免拷贝 |
| 指针接收者 | (p *Person) | 接收实例的指针 | 能 | 修改实例、大结构体、避免拷贝 |
实战对比示例：
package main import "fmt" type Student struct { Score int } // 值接收者：操作的是拷贝，原实例不变 func (s Student) AddScore1(score int) { s.Score += score } // 指针接收者：操作的是原实例，会修改值 func (s *Student) AddScore2(score int) { s.Score += score } func main() { stu := Student{Score: 80} stu.AddScore1(10) fmt.Println(stu.Score) // 输出 80（值接收者，原实例未变） stu.AddScore2(10) fmt.Println(stu.Score) // 输出 90（指针接收者，原实例修改） }
重要补充：Go 会自动处理值和指针的转换，调用方法时无需手动取地址 / 解引用：
- 值实例调用指针接收者方法：stu.AddScore2(10) 等价于 (&stu).AddScore2(10)；
- 指针实例调用值接收者方法：(&stu).AddScore1(10) 等价于 stu.AddScore1(10)。
4. 为非结构体类型定义方法
Go 允许为「自定义的基本类型别名」定义方法（不能直接为原生基本类型如 int 定义）：
package main import "fmt" // 定义int的别名类型 type MyInt int // 为MyInt定义方法 func (m MyInt) Double() MyInt { return m * 2 } func main() { var num MyInt = 5 fmt.Println(num.Double()) // 输出 10 }
二、Go 方法的核心特性
1. 封装性（面向对象核心）
方法可以访问接收者的私有字段（结构体中首字母小写的字段），外部包无法直接访问，只能通过方法操作，实现数据封装：
// model包 - model/person.go package model // Person 结构体（导出） type Person struct { Name string // 导出字段（首字母大写） age int // 私有字段（首字母小写） } // SetAge 方法（导出）：外部包只能通过该方法修改age func (p *Person) SetAge(a int) { if a > 0 && a < 150 { // 增加校验逻辑 p.age = a } } // GetAge 方法（导出）：外部包只能通过该方法读取age func (p *Person) GetAge() int { return p.age } // main包 package main import ( "fmt" "your-project/model" ) func main() { p := &model.Person{Name: "李四"} p.SetAge(25) // 合法：通过方法修改私有字段 fmt.Println(p.GetAge()) // 输出 25 // p.age = 30 // 编译错误：无法访问私有字段 }
2. 方法集（Method Set）
每个类型都有对应的「方法集」，决定该类型的实例 / 指针能调用哪些方法：
- 值类型（T） 的方法集：包含所有「值接收者」方法；
- *指针类型（T） 的方法集：包含所有「值接收者 + 指针接收者」方法；
通俗理解：指针类型能调用所有方法，值类型只能调用值接收者方法（Go 会自动转换，但反向不行）。
3. 方法重载？No！
Go 不支持方法重载（同一类型不能定义同名但参数不同的方法），这是 Go 简洁性的体现，若需不同逻辑，可通过参数可选、多返回值实现。
4. 方法与接口的配合（核心应用）
方法是实现接口的唯一方式：只要类型实现了接口的所有方法，就隐式实现了该接口，无需显式声明（Go 接口的 "鸭子类型"）：
package main import "fmt" // 定义接口 type Speaker interface { Speak() string } // 定义类型1 type Dog struct{} // 实现Speaker接口的Speak方法 func (d Dog) Speak() string { return "汪汪汪" } // 定义类型2 type Cat struct{} // 实现Speaker接口的Speak方法 func (c Cat) Speak() string { return "喵喵喵" } // 通用函数：接收Speaker接口 func MakeSound(s Speaker) { fmt.Println(s.Speak()) } func main() { MakeSound(Dog{}) // 输出 汪汪汪 MakeSound(Cat{}) // 输出 喵喵喵 }
三、Go 方法的典型业务场景
场景 1：结构体封装
最核心场景：为业务实体（如用户、订单、商品）定义方法，封装数据和操作逻辑：
package main import ( "fmt" "time" ) // 订单结构体 type Order struct { OrderID string Amount float64 Status string // 状态：pending/payed/shipped/completed CreateTime time.Time } // 支付订单（指针接收者，修改状态） func (o *Order) Pay() error { if o.Status != "pending" { return fmt.Errorf("订单%s状态异常，无法支付", o.OrderID) } o.Status = "payed" return nil } // 发货（指针接收者） func (o *Order) Ship() error { if o.Status != "payed" { return fmt.Errorf("订单%s未支付，无法发货", o.OrderID) } o.Status = "shipped" return nil } // 获取订单创建时间字符串（值接收者，只读） func (o Order) GetCreateTime() string { return o.CreateTime.Format("2006-01-02 15:04:05") } func main() { order := Order{ OrderID: "ORD20260320001", Amount: 99.9, Status: "pending", CreateTime: time.Now(), } if err := order.Pay(); err != nil { fmt.Println(err) } else { fmt.Println("支付成功，订单状态：", order.Status) // 输出 payed } fmt.Println("订单创建时间：", order.GetCreateTime()) }
场景 2：工具类封装（基本类型扩展）
为基本类型别名定义方法，实现工具类逻辑（如字符串、数字的常用操作）：
package main import "strings" // 字符串别名 type MyString string // 去除空格并转小写 func (s MyString) TrimAndLower() MyString { return MyString(strings.TrimSpace(string(s))) } // 判断是否包含子串 func (s MyString) Contains(sub string) bool { return strings.Contains(string(s), sub) } func main() { var str MyString = " Hello World " fmt.Println(str.TrimAndLower()) // 输出 hello world fmt.Println(str.Contains("World")) // 输出 true }
场景 3：接口实现（多态）
通过方法实现接口，实现多态逻辑（如不同数据源的读取、不同支付方式的处理）：
package main import "fmt" // 支付接口 type Payment interface { Pay(amount float64) string } // 微信支付 type WeChatPay struct{} func (w WeChatPay) Pay(amount float64) string { return fmt.Sprintf("微信支付%.2f元成功", amount) } // 支付宝支付 type AliPay struct{} func (a AliPay) Pay(amount float64) string { return fmt.Sprintf("支付宝支付%.2f元成功", amount) } // 统一支付函数 func UnifiedPay(p Payment, amount float64) { fmt.Println(p.Pay(amount)) } func main() { UnifiedPay(WeChatPay{}, 100.0) // 输出 微信支付100.00元成功 UnifiedPay(AliPay{}, 200.0) // 输出 支付宝支付200.00元成功 }
场景 4：链式调用
方法返回接收者本身（指针），实现链式调用：
package main import "fmt" type Builder struct { content string } func (b *Builder) AddTitle(title string) *Builder { b.content += fmt.Sprintf("<h1>%s</h1>", title) return b // 返回指针，支持链式调用 } func (b *Builder) AddContent(content string) *Builder { b.content += fmt.Sprintf("<p>%s</p>", content) return b } func (b *Builder) Build() string { return b.content } func main() { // 链式调用：简洁直观 html := (&Builder{}). AddTitle("Go方法教程"). AddContent("方法是绑定到类型的函数"). Build() fmt.Println(html) // 输出：<h1>Go方法教程</h1><p>方法是绑定到类型的函数</p> }
总结
- 方法本质：绑定到特定类型的函数，核心是「接收者」，分为值接收者（只读）和指针接收者（可修改）；
- 核心特性：支持封装、配合接口实现多态，无方法重载，指针类型方法集包含所有方法；
- 典型场景：结构体业务建模、工具类扩展、接口实现、链式调用，是 Go 面向对象编程的核心载体。
Go 方法的设计既保留了函数的简洁性，又实现了面向对象的核心思想（封装、多态），是日常开发中处理 "数据 + 逻辑" 的最优方式。