学习碎笔-Golang中的"类"

在 Go 语言中，没有传统面向对象编程中的 “类”（class） 概念，但可以通过 结构体（struct） 和 方法（method） 实现类似面向对象的功能。Go 的设计哲学强调组合（composition over inheritance），而非传统的类继承体系。

如何模拟 “类” 的行为？

1. 定义结构体（类似类的属性）

用 struct 定义数据字段，相当于类的成员变量：

type Person struct {
    Name string
    Age  int
}

2. 定义方法（类似类的方法）

通过 接收者（receiver） 将方法与结构体绑定：

// 值接收者（操作副本）
func (p Person) SayHello() {
    fmt.Printf("Hello, I'm %s, %d years old.\n", p.Name, p.Age)
}

// 指针接收者（操作原对象）
func (p *Person) Grow() {
    p.Age++
}

相关知识：学习碎笔-Golang中什么是接收者

3. 构造函数（类似类的实例化）

Go 没有构造函数的语法，但可以通过工厂函数模拟：

func NewPerson(name string, age int) *Person {
    return &Person{
        Name: name,
        Age:  age,
    }
}

// 使用
p := NewPerson("Alice", 30)

相关知识：学习碎笔-Golang中什么是工厂函数

继承的替代方案：组合（Composition）

Go 通过 结构体嵌入（Embedding） 实现组合：

type Animal struct {
    Name string
}

func (a *Animal) Move() {
    fmt.Println(a.Name, "is moving")
}

// Dog "继承" Animal 的字段和方法
type Dog struct {
    Animal      // 嵌入结构体（相当于继承字段和方法）
    Breed  string
}

// 重写父方法
func (d *Dog) Move() {
    fmt.Println(d.Name, "is running")
}

// 使用
dog := Dog{
    Animal: Animal{Name: "Buddy"},
    Breed:  "Golden Retriever",
}
dog.Move()          // 输出: Buddy is running
dog.Animal.Move()   // 显式调用父方法: Buddy is moving

多态的替代方案：接口（Interface）

Go 通过接口实现多态：

type Shape interface {
    Area() float64
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

type Square struct {
    Side float64
}

func (s Square) Area() float64 {
    return s.Side * s.Side
}

// 多态调用
func PrintArea(s Shape) {
    fmt.Println("Area:", s.Area())
}

// 使用
PrintArea(Circle{Radius: 5})  // 输出圆的面积
PrintArea(Square{Side: 4})    // 输出正方形的面积

相关知识：学习碎笔-Golang中的接口

关键特性总结

Go 通过简洁的语法实现了面向对象的核心思想，避免了传统类继承的复杂性，更强调代码的灵活性和可组合性。