Go 结构体（Struct）与面向对象编程：构建 Car 示例详解

本文旨在帮助 Go 语言初学者理解如何使用结构体（Struct）模拟面向对象编程（OOP）中的对象，并通过构建一个简单的 Car 示例，深入探讨值接收者和指针接收者的区别，以及如何在 Go 中正确地修改结构体内部状态，提供初始化结构体的常用方法。

在 Go 语言中，虽然没有像 Java 或 Python 那样的类（Class）的概念，但我们可以使用结构体（Struct）来定义数据结构，并结合方法（Methods）来实现类似面向对象编程的功能。本文将通过一个 Car 的例子，深入讲解如何在 Go 中使用结构体，以及如何正确地操作结构体的内部状态。

理解值接收者与指针接收者

在 Go 语言中，方法可以有值接收者（Value Receiver）或指针接收者（Pointer Receiver）。这两种接收者在方法调用时有着重要的区别，尤其是在修改结构体内部状态时。

值接收者

当方法使用值接收者时，方法内部操作的是结构体的一个副本。这意味着对结构体内部状态的修改不会影响原始结构体。

指针接收者

当方法使用指针接收者时，方法内部操作的是结构体的指针，可以直接修改原始结构体的内容。

在提供的 Car 示例中，Engine 结构体的 Start() 方法最初使用的是值接收者：

type Engine struct {
    cylinders int
    started   bool
}

func (engine Engine) Start() {
    fmt.Println("Inside the Start() func, started starts off", engine.started)
    engine.started = true
    fmt.Println("Inside the Start() func, then turns to", engine.started)
}

func (engine Engine) IsStarted() bool {
    return engine.started
}

由于 Start() 方法使用值接收者，因此在 Start() 方法内部修改 engine.started 的值，实际上修改的是 engine 的副本，而不是原始的 engine 结构体。因此，在 main() 函数中调用 car.Start() 后，car.engine.IsStarted() 仍然返回 false。

解决方案：使用指针接收者

要解决这个问题，需要将 Engine 结构体的 Start() 方法改为使用指针接收者：

type Engine struct {
    cylinders int
    started   bool
}

func (engine *Engine) Start() {
    fmt.Println("Inside the Start() func, started starts off", engine.started)
    engine.started = true
    fmt.Println("Inside the Start() func, then turns to", engine.started)
}

func (engine *Engine) IsStarted() bool {
    return engine.started
}

通过使用指针接收者 *Engine，Start() 方法可以直接修改原始的 Engine 结构体，从而使 car.engine.IsStarted() 返回 true。

修改 Car 结构体和 main 函数

EasySub – AI字幕生成翻译工具

EasySub 是一款在线 AI 字幕生成器。 它提供AI语音识别、AI字幕生成、AI字幕翻译，本来就很简单的视频剪辑。

下载

同时，为了使代码正常运行，需要修改 Car 结构体，使其包含 Engine 结构体的指针，并在 main 函数中正确初始化 Engine。

package main

import (
    "car/parts"
    "fmt"
)

type Car struct {
    sMake  string
    model  string
    engine *parts.Engine // 使用 Engine 的指针
}

func main() {
    engine := &parts.Engine{cylinders: 4, started: false} // 初始化 Engine
    car := Car{
        sMake:  "AMC",
        model:  "Gremlin",
        engine: engine, // 赋值 Engine 指针
    }
    fmt.Printf("I'm going to work now in my %s %s\n", car.sMake, car.model)

    fmt.Println("I guess I should start my car.")
    car.Start()
    fmt.Println("Engine started?", car.engine.IsStarted())
    // success -- engine started is true  :)
}

func (car Car) Start() {
    fmt.Println("starting engine ...")
    car.engine.Start()
    fmt.Println("you'd think it would be started here ...", car.engine)
    // but it's not
}

相应的 parts/engine.go 文件内容：

package parts

import (
    "fmt"
)

type Engine struct {
    cylinders int
    started   bool
}

func (engine *Engine) Start() {
    fmt.Println("Inside the Start() func, started starts off", engine.started)
    engine.started = true
    fmt.Println("Inside the Start() func, then turns to", engine.started)
    // this is a sanity check
}

func (engine *Engine) IsStarted() bool {
    return engine.started
}

结构体的初始化

Go 语言提供了多种初始化结构体的方式。

1. 直接初始化

   car := Car{
       sMake: "AMC",
       model: "Gremlin",
   }

   这种方式可以指定结构体字段的值。

2. 使用 new() 函数

   car := new(Car)
   car.sMake = "AMC"
   car.model = "Gremlin"

   new() 函数会分配内存并返回指向该内存的指针。

3. 使用构造函数（Constructor）

   虽然 Go 语言没有构造函数的概念，但我们可以自定义函数来初始化结构体。

   func NewCar(make, model string) *Car {
       return &Car{
           sMake: make,
           model: model,
       }
   }
   
   // 使用
   car := NewCar("AMC", "Gremlin")

   构造函数可以提供更灵活的初始化逻辑，例如设置默认值或执行其他初始化操作。

总结

本文通过一个 Car 的例子，详细讲解了如何在 Go 语言中使用结构体模拟面向对象编程，重点介绍了值接收者和指针接收者的区别，以及如何正确地修改结构体的内部状态。此外，还介绍了结构体的多种初始化方式。希望本文能够帮助 Go 语言初学者更好地理解结构体的使用，并能够在实际项目中灵活运用。