OOP

在 Go 中，面向对象编程（OOP）的实现方式与传统的面向对象语言（如 Java 或 C++）有些不同。Go 不支持类和继承，但通过结构体和接口提供了面向对象编程的核心特性。以下是 Go 中 OOP 的主要概念：

结构体（Structs）

结构体是 Go 中用于定义对象的基本构造。你可以将结构体视为一组字段的集合。

type Person struct {
    Name string
    Age  int
}

方法（Methods）

Go 允许为结构体定义方法。方法是附属于特定类型的函数。

func (p *Person) Greet() string {
    return "Hello, my name is " + p.Name
}

接口（Interfaces）

接口定义了一组方法签名。任何实现这些方法的类型都隐式实现了该接口。

type Greeter interface {
    Greet() string
}

多态

通过接口实现多态。不同的类型可以实现相同的接口，从而可以以统一的方式处理不同类型的对象。

func SayHello(g Greeter) {
    fmt.Println(g.Greet())
}

person := Person{Name: "Alice", Age: 30}
SayHello(&person)

嵌入（Embedding）

Go 使用嵌入来实现类似继承的行为。一个结构体可以嵌入另一个结构体，从而获得其字段和方法。

type Employee struct {
    Person
    Position string
}

func (e *Employee) Greet() string {
    return "Hello, I am " + e.Name + " and I work as a " + e.Position
}

通过这些特性，Go 实现了面向对象编程的核心概念，同时保持了语言的简洁和高效。

封装继承多态

在 Go 中，面向对象编程的特性通过不同的方式实现：

封装

Go 通过包级别的可见性来实现封装。标识符（如变量、函数、类型）如果以大写字母开头，则是导出的（公共的），否则是包私有的。

type person struct { // 小写，包私有
    name string
    age  int
}

func NewPerson(name string, age int) *person { // 工厂函数
    return &person{name: name, age: age}
}

func (p *person) GetName() string { // 方法导出
    return p.name
}

继承

Go 通过结构体嵌入实现类似继承的行为。一个结构体可以嵌入另一个结构体，从而获得其字段和方法。

type Employee struct {
    Person  // 嵌入
    Position string
}

func (e *Employee) Greet() string {
    return "Hello, I am " + e.Name + " and I work as a " + e.Position
}

多态

通过接口实现多态。不同的类型可以实现相同的接口，从而以统一的方式处理不同类型的对象。

type Greeter interface {
    Greet() string
}

func SayHello(g Greeter) {
    fmt.Println(g.Greet())
}

type Person struct {
    Name string
}

func (p *Person) Greet() string {
    return "Hello, my name is " + p.Name
}

type Robot struct {
    ID int
}

func (r *Robot) Greet() string {
    return fmt.Sprintf("Greetings, I am robot %d", r.ID)
}

person := &Person{Name: "Alice"}
robot := &Robot{ID: 42}

SayHello(person)
SayHello(robot)

通过这些特性，Go 实现了面向对象编程的核心概念，同时保持了语言的简洁和高效。