Go：Go语言中的“面向对象”

爱写代码的July

于 2024-08-20 18:40:23 发布

阅读量528

点赞数 22

分类专栏： go语言学习文章标签： golang 开发语言后端 go

本文链接：https://blog.csdn.net/Liu_y_xin/article/details/141365010

版权

go语言学习专栏收录该内容

17 篇文章 0 订阅

订阅专栏

Go语言中，实际上并没有“对象”、“类”、“继承”等概念，但是在实际的项目开发中，为了提高代码的可维护性、可扩展性和可复用性，我们不得不使用面向对象的设计理念来编码。因此，我们需要使用Go中的组合、接口等机制实现类似的面向对象特性，如继承、封装和多态。

一什么是面向对象编程？

面向对象编程（Object-Oriented Programming，简称 OOP）是一种编程范式，主要通过对象和类的概念来组织代码和数据。OOP的核心思想是将数据和操作数据的行为封装到对象中，通过对象之间的交互来完成程序的功能。

在OOP中，对象是基本的程序单位，代表现实世界中的实体。对象可以包含数据（属性或字段）和行为（方法或函数）。例如，汽车可以被看作一个对象，它有颜色、型号等属性，同时也有加速、刹车等行为。

类是对象的模板或蓝图。类定义了对象的属性和行为，但类本身并不占用内存，只有在类被实例化为对象时，才会在内存中生成相应的实例。通过类，可以创建多个具有相同属性和行为的对象。

面向对象编程具有三大特性：封装、继承、多态。

封装是将对象的属性和方法隐藏起来，只通过公开的方法来访问或修改对象的状态。通过封装，可以保护对象的内部状态，防止外部不当的访问或修改。这通常通过访问控制机制（如私有属性、保护属性）实现。

class Person:
    def __init__(self, name, age):
        self.name = name    # 公有属性
        self.__age = age    # 私有属性，外部无法直接访问

    def get_age(self):      # 通过公开方法访问私有属性
        return self.__age

person = Person("Alice", 30)
print(person.get_age())     # 输出: 30
# print(person.__age)       # 会报错，无法直接访问私有属性

继承指允许一个类从另一个类继承属性和方法，从而实现代码复用。子类可以继承父类已有的功能，还可以对其进行扩展或修改。继承是面向对象中代码复用的重要机制。

class Animal:
    def speak(self):
        print("The animal makes a sound.")

class Dog(Animal):  # Dog类继承自Animal类
    def speak(self):
        print("The dog barks.")

dog = Dog()
dog.speak()  # 输出: The dog barks.

多态是指相同的接口（方法）可以表现出不同的行为。通过多态，不同类型的对象可以以相同的方式进行操作，而实际执行的操作取决于对象的类型。这使得代码更加灵活和可扩展。

class Animal:
    def speak(self):
        pass

class Cat(Animal):
    def speak(self):
        print("Meow")

class Dog(Animal):
    def speak(self):
        print("Woof")

def make_sound(animal):
    animal.speak()

cat = Cat()
dog = Dog()
make_sound(cat)  # 输出: Meow
make_sound(dog)  # 输出: Woof

二面向对象编程的优势有哪些？

提高代码的可维护性：通过封装和继承，代码可以更加模块化和可扩展，便于维护和修改。

增强代码的复用性：通过继承和类的重用，可以减少代码重复。

提升代码的灵活性和扩展性：通过多态，代码可以适应不同的需求场景。

三 Go语言中的面向对象如何实现？

1.结构体

Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

我们可以使用以下语句来定义一个结构体：

type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}

func (接受者) 方法名称([方法参数]) [方法返回值] {
  
}

例如，我们定义一个“书本”结构体，其中包括多个属性，如题目、作者、科目等...不同的属性可能有着不同的数据类型。

type Books struct {
	title string
	author string
	subject string
	book_id int
}
 
func (b Books) sale() {
 fmt.Println(b.title, "出售一本书")
}

我们可以创建一个结构体类型的变量并且访问它的属性：

    book := Books{"go", "July", "Go", 0011}
	fmt.Println(book.author)
	book.sale()

我们可以粗略的理解为结构体就是一个类，结构体的字段就是对象的属性，结构体的方法就类似于对象中的方法，方法一定要有一个接收者，这里的接收者为结构体，也就是将这个方法归属到结构体中，类似在类中定义一个方法，这个方法就是属于这个类。我们所创建的book变量是对类的实例化对象，我们可以通过对象去调用类中的方法。

2.继承性

Go语言中的继承使用结构体嵌套的方式实现，通过嵌入一个结构体，嵌入的结构体可以访问外部结构体的字段和方法，从而实现代码复用。

// 基础结构体
type Animal struct {
	Name string
}

// 基础结构体的方法
func (a Animal) Speak() {
	fmt.Println(a.Name, "makes a sound.")
}

// 组合方式嵌入(类似于Gog类继承了父类Animal，并有自己的属性)
type Dog struct {
	Animal
	Breed string
}

func main() {
	dog := Dog{Animal{Name: "Rex"}, "Golden Retriever"}
	dog.Speak() // 调用Animal的Speak方法
}

3.封装性

Go语言通过包级别的访问控制实现封装。一个标识符（函数、变量、结构体等）如果以大写字母开头，它是导出的（公开的），可以在包外部访问；如果以小写字母开头，则是未导出的（私有的），只能在包内部访问。

package main
import "fmt"

type person struct {  // 小写字母开头，未导出，包外不可访问
    name string       // 小写字母开头，未导出，包外不可访问
}

func (p *person) GetName() string { // 大写字母开头，导出，外部包可访问
    return p.name
}

func (p *person) setName(name string) { // 小写字母开头，未导出
    p.name = name
}

func main() {
    p := person{name: "John"} 
    fmt.Println(p.GetName())  // 通过公开方法访问私有属性
    p.setName("Alice")        // 修改私有属性
    fmt.Println(p.GetName())
}

4.多态性

Go语言通过接口来实现多态。接口定义了方法的集合，任何类型只要实现了这些方法，就可以被认为实现了该接口。接口变量可以保存实现了该接口的任何类型的对象。

定义接口的语法如下：

type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

Go 语言中的接口是隐式实现的，也就是说，如果一个类型实现了一个接口定义的所有方法，那么它就自动地实现了该接口。在下面的例子中，我们有一个接口，其中有一个未被实现的方法Speak（），我们分别使用Cat和Dog结构体去实现该方法，方法的接受者就是对应的结构体类型。这样，我们就实现了相同的接口表现出不同的行为，也就是多态性。

package main
import "fmt"

// 定义接口
type Speaker interface {
    Speak()
}

// 结构体类型
type Cat struct{}
type Dog struct{}

// 实现接口方法
func (c Cat) Speak() {
    fmt.Println("Meow!")
}

func (d Dog) Speak() {
    fmt.Println("Woof!")
}

func makeSound(s Speaker) {
    s.Speak()
}

func main() {
    cat := Cat{}
    dog := Dog{}

    makeSound(cat) // 输出：Meow!
    makeSound(dog) // 输出：Woof!
}