Go 结构体（Struct）与面向对象编程：构建 Car 示例详解-Golang-PHP中文网

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

DDD

发布： 2025-10-16 13:56:01

原创

180人浏览过

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 函数

即构数智人

即构数智人是由即构科技推出的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 语言提供了多种初始化结构体的方式。

直接初始化
```
car := Car{
    sMake: "AMC",
    model: "Gremlin",
}
```
登录后复制
这种方式可以指定结构体字段的值。
使用 new() 函数
```
car := new(Car)
car.sMake = "AMC"
car.model = "Gremlin"
```
登录后复制
new() 函数会分配内存并返回指向该内存的指针。
使用构造函数（Constructor）

虽然 Go 语言没有构造函数的概念，但我们可以自定义函数来初始化结构体。
```
func NewCar(make, model string) *Car {
    return &Car{
        sMake: make,
        model: model,
    }
}

// 使用
car := NewCar("AMC", "Gremlin")
```
登录后复制
构造函数可以提供更灵活的初始化逻辑，例如设置默认值或执行其他初始化操作。