Wie man in Golang erbt

In der Go-Sprache gibt es keine „Klasse“, die in traditionellen objektorientierten Sprachen definiert ist, daher gibt es keine sogenannte „Vererbung“. Die Go-Sprache bietet jedoch eine Methode, um eine ähnliche Vererbung durch Komposition zu erreichen, die als Einbettung bezeichnet wird.

Durch das Einbetten können wir einen Typ in einen anderen Typ einbetten, sodass der eingebettete Typ direkt auf die Eigenschaften und Methoden des Typs zugreifen kann, in den er eingebettet ist, ohne über eine Schnittstelle oder auf andere Weise darauf zugreifen zu müssen . Dieser Prozess ähnelt der traditionellen „Vererbung“, ist jedoch flexibler.

Im Folgenden zeigen wir anhand einiger Beispiele, wie man durch Einbettung vererbungsähnliche Funktionen erreichen kann.

1. Grundlegendes Beispiel

Wir definieren zunächst ein paar Grundstrukturen, Hunde, Katzen und Menschen:

type Dog struct {
    name string
}

func (d Dog) Bark() {
    fmt.Println(d.name, ": 汪汪汪！")
}

type Cat struct {
    name string
}

func (c Cat) Mew() {
    fmt.Println(c.name, ": 喵喵喵！")
}

type Person struct {
    name string
}

func (p Person) Speak() {
    fmt.Println(p.name, ": 你好！")
}

#🎜🎜 #Jetzt Wir möchten einen Tiertyp schaffen, der Hunde und Katzen „erben“ kann und auch über eigene Eigenschaften und Methoden wie Farbe und Laufgeschwindigkeit verfügt. Wir können es so definieren:

type Animal struct {
    Dog
    Cat
    color       string
    runSpeed    int
}

func (a Animal) Run() {
    fmt.Println(a.color, "的动物以", a.runSpeed, "km/h的速度奔跑！")
}

In dieser Definition bettet der Typ „Tier“ die Typen „Hund“ und „Katze“ ein. Dies bedeutet, dass vom Typ Animal instanziierte Objekte direkt auf die Eigenschaften und Methoden der Typen Dog und Cat zugreifen können. Wir können auch unsere eigenen Eigenschaften und Methoden für den Tiertyp definieren, z. B. Farbe und runSpeed, um die Farbe und Laufgeschwindigkeit des Tieres darzustellen, und eine Run-Methode definieren, um die Laufaktion des Tieres zu beschreiben.

Jetzt erstellen wir ein Animal-Objekt und sehen, wie es funktioniert:

func main() {
    d := Dog{name: "小黑"}
    c := Cat{name: "小白"}
    a := Animal{d, c, "黑白相间", 50}
    a.Bark()    // 小黑 : 汪汪汪！
    a.Mew()     // 小白 : 喵喵喵！
    a.Run()     // 黑白相间 的动物以 50 km/h的速度奔跑！
}

Wir können sehen, dass durch die Einbettung der Typen Dog und Cat das Animal-Objekt direkt Bark und aufgerufen werden kann Mew-Methoden ohne Verwendung von Schnittstellen oder anderen Mitteln. Dieser Ansatz ermöglicht es uns, eine ähnliche Funktionalität zu erreichen, ohne „Vererbung“ im herkömmlichen Sinne zu verwenden.

Eingebetteter benutzerdefinierter Typ

Wir können einen benutzerdefinierten Typ in einen anderen benutzerdefinierten Typ einbetten, um einen ähnlichen Effekt wie bei der Vererbung zu erzielen. Definieren wir nun einen Personentyp und einen Studententyp und betten den Personentyp in den Studententyp ein:

type Person struct {
    name string
    age  int
    sex  string
}

type Student struct {
    Person
    class string
    score float64
}

In dieser Definition bettet der Studententyp den Personentyp ein. Beim Instanziieren eines Objekts vom Typ Student können Sie die Eigenschaften und Methoden von Person verwenden. Beispielsweise können wir ein Schülerobjekt instanziieren und seinen Namen, sein Alter, sein Geschlecht, seine Klasse und seine Noten festlegen:

func main() {
    s := Student{
        Person: Person{
            name: "小明",
            age:  18,
            sex:  "男",
        },
        class: "高三一班",
        score: 92.5,
    }
    fmt.Println("姓名：", s.name)
    fmt.Println("年龄：", s.age)
    fmt.Println("性别：", s.sex)
    fmt.Println("班级：", s.class)
    fmt.Println("成绩：", s.score)
}

Wenn wir dieses Programm ausführen, können wir die Ausgabe wie folgt sehen:

姓名： 小明
年龄： 18
性别： 男
班级： 高三一班
成绩： 92.5

Wir können sehen, dass das Student-Objekt direkt auf die Eigenschaften und Methoden des Person-Typ-Objekts zugreifen kann, einschließlich Attributen wie Name, Alter und Geschlecht.

verschachtelte Einbettung

Es ist auch möglich, mehrere Typen innerhalb eines Typs zu verschachteln. Wir können den Tiertyp in einen anderen Typ einbetten, um mehr Funktionen zu erreichen. Definieren wir jetzt zum Beispiel einen Zoo-Typ:

type Zoo struct {
    Animal
    name    string
    address string
}

func (z Zoo) ShowInfo() {
    fmt.Println("这是", z.name, ", 地址是", z.address)
    z.Run()
}

In der Definition dieses Typs betten wir den Animal-Typ in den Zoo-Typ ein. Auf diese Weise kann der Zoo-Typ direkt auf die Eigenschaften und Methoden des Animal-Typs zugreifen, einschließlich der Run-Methode. Wir definieren eine weitere ShowInfo-Methode, um den Namen und die Adresse des Zoos auszugeben, und rufen die Run-Methode des Typs Animal auf, um die laufenden Tiere anzuzeigen.

Jetzt erstellen wir ein Zoo-Objekt und testen seine Methoden:

func main() {
    d := Dog{name: "小黑"}
    c := Cat{name: "小白"}
    a := Animal{d, c, "黑白相间", 50}
    z := Zoo{a, "北京动物园", "北京市海淀区清华科技园路"}
    z.ShowInfo()
}

Wenn wir dieses Programm ausführen, können wir die Ausgabe wie folgt sehen:

这是 北京动物园 , 地址是 北京市海淀区清华科技园路
黑白相间 的动物以 50 km/h的速度奔跑！

# 🎜 🎜#Wir können sehen, dass wir durch die Verschachtelung des Animal-Typs in den Zoo-Typ einen Typ mit mehr Funktionen erstellen können, der Zooinformationen und die laufenden Aktionen von Tieren anzeigen kann.

Zusammenfassung

Obwohl es in der Go-Sprache keine durch traditionelle objektorientierte Sprachen definierten Klassen- und Vererbungskonzepte gibt, ermöglicht uns das Konzept der Einbettung, auf die Verwendung traditioneller Methoden zu verzichten Vererbungsmethoden sind bei ähnlichen Funktionen flexibler und bequemer. Anhand der obigen Beispiele können wir sehen, dass die Einbettung es einfach macht, einen Typ zu erstellen, der Untertypen enthält, und deren Methoden und Eigenschaften bequem aufzurufen.

Das obige ist der detaillierte Inhalt vonWie man in Golang erbt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!