go中的类操作 | 豆包MarsCode AI刷题

Lu627
44 阅读4分钟

go类相关操作

Go 语言中的类相关操作

Go 语言虽然没有 class 关键字,但是可以使用 struct 来模拟类的功能。在 Go 中,我们可以通过以下方式来实现类似于面向对象编程的功能:

  1. 封装和绑定方法:

    • Go 中没有 public 和 private 关键字,但是可以通过首字母大小写来控制成员的可见性。
    • 可以在 struct 类型上定义方法,这些方法就相当于类的成员方法。方法的定义格式为 func (receiver Type) MethodName(params) returnType。
    • 方法的 receiver 可以是指针类型,也可以是值类型。使用指针类型可以修改 struct 的成员,而值类型则不能直接修改成员。

  2. 继承和多态:

    • Go 语言没有传统面向对象编程中的继承机制,但是可以通过组合的方式来实现代码重用。
    • 可以定义一个嵌入式的 struct,将其他 struct 嵌入进来,从而实现代码的复用。
    • Go 语言支持接口(interface)的概念,通过接口可以实现多态的效果。不同的类型可以实现同一个接口,从而具有相同的行为。

  3. 构造函数和初始化:

    • Go 语言没有传统面向对象编程中的构造函数,但是可以定义一个初始化函数来完成对象的初始化。
    • 通常使用工厂函数(NewXXX())来创建对象,并在函数内部完成对象的初始化。

综上所述,虽然 Go 语言没有传统意义上的类,但是通过 struct 和方法绑定,我们仍然可以实现面向对象编程的核心概念,如封装、继承和多态。同时,Go 语言提供了一些独特的特性,如接口和组合,使得代码更加灵活和可扩展。

go语言支持类的操作，但是没有class关键字，使用struct来模拟类

Go 语言中的类相关操作

1. 结构体(Struct)和方法

在 Go 语言中,我们使用结构体(Struct)来模拟类的概念。结构体可以包含各种类型的成员变量,并且可以定义方法与之关联。

type Person struct {
    Name string
    Age  int
}

func (p *Person) Introduce() {
    fmt.Printf("Hello, my name is %s and I'm %d years old.\n", p.Name, p.Age)
}

在上面的例子中,我们定义了一个 Person 结构体,并为其添加了一个 Introduce 方法。这个方法的 receiver 是一个指针类型 *Person，这意味着我们可以通过指针来修改结构体的成员变量。

2. 继承和组合

Go 语言没有传统面向对象编程中的继承机制,但是可以通过组合的方式来实现代码重用。

type Employee struct {
    Person
    JobTitle string
}

func (e *Employee) Introduce() {
    fmt.Printf("Hello, my name is %s, I'm %d years old and my job title is %s.\n", e.Name, e.Age, e.JobTitle)
}

在上面的例子中,我们定义了一个 Employee 结构体,它嵌入了 Person 结构体。这样 Employee 就可以直接访问 Person 结构体的成员变量和方法。我们还为 Employee 定义了自己的 Introduce 方法,这就实现了方法的重写和多态。

3. 接口(Interface)

Go 语言支持接口(Interface)的概念,通过接口可以实现多态的效果。不同的类型可以实现同一个接口,从而具有相同的行为。

type Speaker interface {
    Speak()
}

type Dog struct {
    Name string
}

func (d *Dog) Speak() {
    fmt.Printf("%s says: Woof!\n", d.Name)
}

type Cat struct {
    Name string
}

func (c *Cat) Speak() {
    fmt.Printf("%s says: Meow!\n", c.Name)
}

在上面的例子中,我们定义了一个 Speaker 接口,它要求实现 Speak 方法。Dog 和 Cat 两个结构体都实现了这个接口,因此它们都具有 Speak 方法,从而实现了多态的效果。

4. 构造函数和初始化

Go 语言没有传统面向对象编程中的构造函数,但是可以定义一个初始化函数来完成对象的初始化。通常使用工厂函数(NewXXX())来创建对象,并在函数内部完成对象的初始化。

func NewPerson(name string, age int) *Person {
    return &Person{
        Name: name,
        Age:  age,
    }
}

1.封装-绑定方法

package main
​
import "fmt"
​
//Person类，绑定方法：Eat，Run，Laugh, 成员
//public，private
/*
class Person {
public :
    string name
    int age
​
public :
    Eat() {
        xxx
    }
}
​
*/
​
//任何type的类型，都可以绑定方法
type MyInt1 int
​
func (mi *MyInt1) printMyInt() {
    fmt.Println("MyInt value is:", *mi)
}
​
type Person struct {
    //成员属性:
    name   string
    age    int
    gender string
    score  float64
}
/*
Person:::Eat() {
    
}
*/
​
//在类外面绑定方法
func (this *Person) Eat() {
    //fmt.Println("Person is eating")
    //类的方法，可以使用自己的成员
    //fmt.Println(this.name + " is eating!")
    this.name = "Duke"
}
​
func (this Person) Eat2() {
    fmt.Println("Person is eating")
    //类的方法，可以使用自己的成员
    this.name = "Duke"
}
​
func main() {
    lily := Person{
        name:   "Lily",
        age:    30,
        gender: "女生",
        score:  10,
    }
​
    lily1 := lily
​
    fmt.Println("Eat，使用p *Person，修改name的值 ...")
    fmt.Println("修改前lily:", lily) //lily
    lily.Eat()
    fmt.Println("修改后lily:", lily) //Duke
​
    fmt.Println("Eat2，使用p Person，但是不是指针 ...")
    fmt.Println("修改前lily:", lily1) //lily
    lily1.Eat2()
    fmt.Println("修改后lily:", lily1) //lily
​
    var myint1 MyInt1 = 100
    myint1.printMyInt()
}
​
avatar
文章
阅读
粉丝