【go语言】go语言如何实现面向对象的编程

公告

View Post

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

一什么是面向对象编程？

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

在OOP中，对象是基本的程序单位，代表现实世界中的实体。

对象可以包含

　　　　　　数据（属性或字段）

行为（方法或函数）。

例如，汽车可以被看作一个对象，它有颜色、型号等属性，同时也有加速、刹车等行为。

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

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

【封装】是将对象的属性和方法隐藏起来，只通过公开的方法来访问或修改对象的状态。通过封装，可以保护对象的内部状态，防止外部不当的访问或修改。这通常通过访问控制机制（如私有属性、保护属性）实现。
【继承】指允许一个类从另一个类继承属性和方法，从而实现代码复用。子类可以继承父类已有的功能，还可以对其进行扩展或修改。继承是面向对象中代码复用的重要机制。
【多态】是指相同的接口（方法）可以表现出不同的行为。通过多态，不同类型的对象可以以相同的方式进行操作，而实际执行的操作取决于对象的类型。这使得代码更加灵活和可扩展。

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

2.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.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方法
}

2.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())
}

2.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!
}

posted on 2024-11-25 22:24 无信不立阅读(138) 评论(0) 收藏举报

刷新页面返回顶部

无信不立

公告

View Post