方法

|
package school
 
import "fmt"
 
type Student struct {
    Name   string
    Age    int
    Grade  string
    Scores map[string]int
}
 
// 传统函数方式
func GetStudentInfo(s Student) string {
    return fmt.Sprintf("学生：%s，年龄：%d，年级：%s", s.Name, s.Age, s.Grade)
}
 
// 作为Student类型的方法
func (s Student) GetInfo() string {
    return fmt.Sprintf("学生：%s，年龄：%d，年级：%s", s.Name, s.Age, s.Grade)
}

|
student := Student{
    Name:  "小明",
    Age:   16,
    Grade: "高一",
    Scores: map[string]int{
        "数学": 85,
        "语文": 92,
        "英语": 78,
    },
}
 
fmt.Println(GetStudentInfo(student)) 

|
// 计算平均分
func (s Student) GetAverageScore() float64 {
    if len(s.Scores) == 0 {
        return 0.0
    }
    
    total := 0
    for _, score := range s.Scores {
        total += score
    }
    return float64(total) / float64(len

|
student := Student{
    Name:  "小红",
    Age:   15,
    Grade: "初三",
    Scores: map[string]int{
        "数学": 95,
        "语文": 88,
        "英语": 92,
        "物理": 90,
    },
}
 
fmt.

|
type Class struct {
    Name     string
    Students []Student
    Teacher  string
}
 
// 获取班级平均分
func (c Class) GetClassAverage() float64 {
    if len(c.Students) == 0 {
        return 0.0
    }
    
    total := 0.0
    for _, student := range

|
type Counter struct {
    count int
    name  string
}
 
// 值接收者方法 - 只能读取数据
func (c Counter) GetCount() int {
    return c.count
}
 
// 指针接收者方法 - 可以修改数据
func (c *Counter) Increment() {
    c.count++
}
 
func (c 

|
// 创建计数器
counter := Counter{count: 0, name: "默认计数器"}
 
// 使用值接收者方法 - 只读取
fmt.Println(counter.GetCount()) // 0
 
// 使用指针接收者方法 - 可以修改
counter.Increment()
fmt.Println(counter.GetCount()) // 1
 
counter.Increment()
counter.Increment()
fmt.Println(counter.GetCount()) // 3

|
myCounter := Counter{count: 5, name: "测试"}
 
// 这些调用是等价的
myCounter.Increment()  // 编译器自动转换为 (&myCounter).Increment()
(&myCounter).Increment() // 显式写法
 
// 但是我们不能在字面量上调用指针接收者方法
// Counter{count: 1}.Increment() // 编译错误！

|
ptr := &myCounter
fmt.Println(ptr.GetCount()) // 编译器自动转换为 (*ptr).GetCount()

|
// IntList是整数的链表
// nil *IntList表示空列表
type IntList struct {
    Value int
    Tail  *IntList
}
 
// Sum返回列表元素的总和
func (list *IntList) Sum() int {
    if list == nil {
        return 0
    }
    return list.Value + list.Tail.Sum()
}

|
package url
 
// Values将字符串键映射到值列表
type Values map[string][]string
 
// Get返回与给定键关联的第一个值，
// 如果没有则返回""
func (v Values) Get(key string) string {
    if vs := v[key]; len(vs) > 0 {
        return vs[0]
    }
    return

|
m := url.Values{"lang": {"en"}} // 直接构造
m.Add("item", "1")
m.Add("item", "2")
fmt.Println(m.Get("lang"))  // "en"
fmt.Println(m.Get("q"))     // ""
fmt.Println

|
package shop
 
import (
    "fmt"
    "time"
)
 
// 基础商品信息 - 这是我们的核心类型
type Product struct {
    ID          string
    Name        string
    Description string
    Price       float64
    Category    string
}
 
// 商品的基础方法
func (p Product) GetBasicInfo() string

|
// 完整商品信息 - 通过嵌入组合多个类型
type CompleteProduct struct {
    Product    // 嵌入基础商品信息
    Inventory  // 嵌入库存信息
    Promotion  // 嵌入促销信息
    Brand      string // 品牌信息
    Tags       []string // 商品标签
}
 
// 为完整商品添加自己的方法
func (cp CompleteProduct) GetFullInfo() string {
    info := cp.GetBasicInfo() + "\n"

|
// 创建一个完整的商品
laptop := CompleteProduct{
    Product: Product{
        ID:          "LAP001",
        Name:        "高性能笔记本电脑",
        Description: "最新款处理器，16GB内存",
        Price:       5999.00,
        Category:    "电子产品",
    },
    Inventory: Inventory{
        StockQuantity: 50,
        MinStock:      10,
        LastUpdated:   time.Now(),

|
// 调用从Product提升的方法
fmt.Println(laptop.GetBasicInfo()) // "商品ID: LAP001, 名称: 高性能笔记本电脑, 价格: 5999.00元"
fmt.Println(laptop.IsExpensive())  // true
 
// 调用从Inventory提升的方法
fmt.Println(laptop.GetStockInfo()) // "库存数量: 50, 最低库存: 10"
fmt.Println(laptop.IsLowStock())   // false
 
// 调用从Promotion提升的方法
fmt.Println(laptop.GetDiscountInfo()) // "暂无促销活动"
 
// 调用CompleteProduct自己的方法
fmt.Println

|
// 错误：不能将CompleteProduct当作Product使用
// func ProcessProduct(p Product) { ... }
// ProcessProduct(laptop) // 编译错误！
 
// 正确：需要明确指定嵌入的Product字段
func ProcessProduct(p Product) {
    fmt.Println("处理商品：", p.GetBasicInfo())
}
 
ProcessProduct(laptop.Product) // 正确 - 传递嵌入的Product字段

|
// 共享基础商品信息的商品变体
type ProductVariant struct {
    *Product        // 嵌入指针类型
    Color           string
    Size            string
    VariantID       string
}
 
// 创建基础商品
baseProduct := &Product{
    ID:          "BASE001",
    Name:        "经典T恤",
    Description: "舒适透气的纯棉T恤",
    Price:       99.00,
    Category:    "服装",

|
// 时间信息类型
type TimeInfo struct {
    CreatedAt time.Time
    UpdatedAt time.Time
}
 
func (t TimeInfo) GetTimeInfo() string {
    return fmt.Sprintf("创建时间: %s, 更新时间: %s", 
        t.CreatedAt.Format("2006-01-02 15:04:05"),
        t.UpdatedAt.Format

|
func (s SuperProduct) GetBasicInfo() string {
    return s.Product.GetBasicInfo()
}

|
// 基础日志接口
type Logger interface {
    Log(message string)
}
 
// 控制台日志
type ConsoleLogger struct {
    Level string
}
 
func (c ConsoleLogger) Log(message string) {
    fmt.Printf("[%s] %s\n", c.Level, message)
}

|
type Student struct {
    Name   string
    Age    int
    Grade  string
    Scores map[string]int
}
 
func (s Student) GetInfo() string {
    return fmt.Sprintf("学生：%s，年龄：%d，年级：%s", s.Name, s.Age, s.Grade)
}
 

|
// 创建学生
alice := Student{
    Name:   "Alice",
    Age:    16,
    Grade:  "高一",
    Scores: map[string]int{"数学": 85, "语文": 92, "英语": 78},
}
 
bob := Student{
    Name:   "Bob",

|
// 通用的学生信息处理函数
func ProcessStudentInfo(processor func() string) {
    result := processor()
    fmt.Println("处理结果：", result)
}
 
// 使用方法值作为参数
ProcessStudentInfo(alice.GetInfo)        // 处理Alice的信息
ProcessStudentInfo(bob.GetInfo)          // 处理Bob的信息
ProcessStudentInfo(alice.GetAverageScore) // 处理Alice的平均分

|
// 方法表达式
getInfoFunc := Student.GetInfo           // 类型级别的方法引用
getAverageFunc := Student.GetAverageScore // 类型级别的方法引用
updateGradeFunc := (*Student).UpdateGrade // 指针接收者的方法表达式
 
// 使用方法表达式（需要提供接收者作为第一个参数）
fmt.Println(getInfoFunc(alice))         // "学生：Alice，年龄：16，年级：高一"
fmt.Println(getInfoFunc(bob))           // "学生：Bob，年龄：15，年级：初三"
 
fmt.Println(getAverageFunc(alice))      // 85.0
fmt.Println(

|
// 定义不同的处理方法
type StudentProcessor struct {
    students []Student
}
 
func (sp StudentProcessor) ProcessByMethod(method func(Student) string) {
    for _, student := range sp.students {
        result := method(student)
        fmt.Println(result)
    }
}
 
// 使用方法表达式

|
// bank/account.go
package bank
 
type Account struct {
    balance float64  // 私有字段，只能在bank包内访问
    owner   string   // 私有字段
    history []string // 私有字段，记录交易历史
}
 
// 构造函数
func NewAccount(owner string, initialBalance float64) *Account {
    return &Account{
        balance: initialBalance,
        owner:   owner,

|
// main.go
package main
 
import "bank"
 
func main() {
    account := bank.NewAccount("张三", 1000.0)
    
    // 正确的使用方式
    fmt.Println("余额:", account.Balance()) // 1000.0
    account.Deposit(500.0)
    fmt.Println("存款后余额:", account.

|
// 优化后的Account实现
type Account struct {
    balance float64
    owner   string
    // 使用更高效的存储方式
    transactions []Transaction
}
 
type Transaction struct {
    Type      string
    Amount    float64
    Timestamp time.Time
}
 
// 外部接口保持不变
func (a *Account) Balance() float64

|
// 添加更严格的业务规则
func (a *Account) Withdraw(amount float64) error {
    if amount <= 0 {
        return errors.New("取款金额必须大于0")
    }
    if amount > a.balance {
        return errors.New("余额不足")
    }
    if amount > 50000.0

|
// bank/transfer.go
package bank
 
// Transfer 可以在同一包内访问Account的私有字段
func Transfer(from, to *Account, amount float64) error {
    if err := from.Withdraw(amount); err != nil {
        return err
    }
    
    // 可以直接访问私有字段（在同一包内）
    to.balance += amount
    to.addTransaction(

|
// 不需要封装的例子
type Point struct {
    X, Y float64  // 直接暴露字段
}
 
type Duration int64  // 本质上是数值类型

|
矩形: 宽=5.0, 高=3.0
面积: 15.00
周长: 16.00
是否为正方形: false
 
缩放2倍后: 宽=10.0, 高=6.0
新面积: 60.00

|
姓名: 张三
年龄: 20
平均分: 87.67
 
修改后:
年龄: 21
成绩: [85 90 88 92]
平均分: 88.75

|
狗: 旺财, 3岁, 品种: 金毛
  叫声: Woof!
  移动: Moving
 
鸟: 小鸟, 1岁, 会飞: true
  叫声: Some sound
  移动: Flying

|
结果1:
HelloWorld
Go
结果2:
第一行
第二行
第三行
结果3:
清空后重新开始