Golang hat keine Klasse

Objekte und Klassen in der Go-Sprache

Unter vielen Programmiersprachen ist die objektorientierte Programmierung (kurz OOP) ein beliebtes Programmierparadigma, bei dem Daten mit Methoden kombiniert werden, um modulare, wiederverwendbare Elemente zu erstellen Code. In traditionellen OOP-Sprachen (wie Java, C++ usw.) sind Klassen eines der Kernkonzepte von OOP. Funktionen wie Kapselung, Vererbung und Polymorphismus können durch Klassen erreicht werden. Aber in der Go-Sprache gibt es kein Klassenschlüsselwort, und OOP in der Go-Sprache unterscheidet sich in vielerlei Hinsicht von der traditionellen OOP-Sprache.

Objektorientiert in der Go-Sprache

In der Go-Sprache wird die objektorientierte Implementierung hauptsächlich durch Strukturen (Struct) und Methoden (Method) implementiert eine Struktur, um ein Objekt zu bilden. In der Go-Sprache werden Strukturen auf ähnliche Weise definiert und können auch Mitgliedsvariablen und Mitgliedsmethoden enthalten.

Eine einfache Go-Struktur ist wie folgt definiert:

type Person struct {
    Name    string
    Age     int
    Address string
}

In diesem Beispiel definieren wir eine Struktur namens Person, die drei Felder enthält: Name, Alter und Adresse. Auf die Mitgliedsvariablen dieser Struktur kann über die Syntax „.“ zugegriffen werden, zum Beispiel:

var person Person
person.Name = "Tom"
person.Age = 20
person.Address = "New York"

Auf diese Weise erstellen wir eine Instanz mit dem Namen „person“, und auf die Felder kann über „.“ zugegriffen werden.

Durch die Struktur können wir die Attribute (Mitgliedsvariablen) der Instanz definieren, aber wie wird die Instanz betrieben? In der Go-Sprache können Sie Methoden für eine Struktur definieren und die Mitgliedsvariablen der Struktur innerhalb der Methode bedienen.

Eine einfache Go-Methode ist wie folgt definiert:

func (p *Person) GetAge() int {
    return p.Age
}

In diesem Beispiel definieren wir eine Methode namens GetAge, die das Alter der aktuellen Strukturinstanz ( Age) zurückgibt. Es ist zu beachten, dass diese Methode einen Empfänger vom Zeigertyp verwendet, was bedeutet, dass sie die Eigenschaften der Strukturinstanz ändern kann.

Erstellung und Verwendung von Objekten

Die Art und Weise, Objekte in der Go-Sprache zu erstellen, unterscheidet sich auch von anderen OOP-Sprachen. In traditionellen OOP-Sprachen können wir Objekte über Schlüsselwörter wie „new“ oder „constructor“ erstellen. Aber in der Go-Sprache müssen wir nur eine Instanz über die Strukturdefinition erstellen und dann den Zeiger der Instanz zur Operation an die Methode übergeben.

Ein einfaches Beispiel für die Erstellung und Verwendung von Go-Objekten lautet wie folgt:

var person *Person = new(Person)
person.Name = "Tom"
person.Age = 20
person.Address = "New York"
fmt.Println("The age of person is", person.GetAge()) // 输出 The age of person is 20

In diesem Beispiel erstellen wir zunächst eine Instanz mit dem Namen person über die Funktion new() und legen sie dann fest seine Eigenschaften. Schließlich rufen wir die GetAge()-Methode der Person auf, um das Alter der Person zu ermitteln.

Es ist zu beachten, dass Sie in der Go-Sprache den Operator „&“ verwenden können, um einen Zeiger auf eine Variable zu erhalten, zum Beispiel:

var person Person
var p *Person = &person

Hier definieren wir zunächst a Die Strukturinstanz namens person wird dann verwendet, um ihren Zeiger mit dem „&“-Operator zu erhalten, und der Zeiger wird der p-Variablen zugewiesen. Sie können den „&“-Operator auch direkt verwenden, um den Zeiger einer neu erstellten Strukturinstanz abzurufen, zum Beispiel:

var p *Person = &Person{}

Auf diese Weise erstellen wir ein Personenobjekt mit dem Namen p und setzen seinen Zeiger auf Zugewiesen an die p-Variable.

Vererbung und Polymorphismus

In traditionellen OOP-Sprachen sind Vererbung und Polymorphismus zwei sehr wichtige Merkmale. Sie können die Wiederverwendbarkeit und Flexibilität von Code erheblich verbessern. Da es in der Go-Sprache jedoch kein Klassenschlüsselwort gibt, sind die Implementierung von Vererbung und Polymorphismus etwas anders.

In der Go-Sprache wird die Vererbung durch „Embedded Struct“ implementiert. Dies ist der Vererbung in der Java-Sprache sehr ähnlich, aber im Gegensatz zu Java erbt die verschachtelte Struktur in der Go-Sprache nicht standardmäßig alle Mitglieder der übergeordneten Struktur.

Ein Beispiel für eine einfache verschachtelte Go-Struktur lautet wie folgt:

type Driver struct {
    Name string
}

type Car struct {
    *Driver
    Brand string
}

func (d *Driver) Drive() {
    fmt.Println(d.Name, "is driving")
}

func main() {
    var john *Driver = &Driver{Name: "John"}
    var benz *Car = &Car{Driver: john, Brand: "Benz"}
    benz.Drive() // 输出 John is driving
}

In diesem Beispiel definieren wir eine Struktur namens Driver und eine Struktur namens Car Structure, in der Driver verschachtelt ist Auto. Die Driver-Struktur verfügt über eine Methode namens Drive, mit der der Name des Fahrers ausgegeben wird. Wir können sehen, dass der Fahrer im Auto verschachtelt ist und die Drive-Methode des Fahrers über die Autoinstanz aufgerufen werden kann. Dies implementiert eine einfache Vererbung.

In der Go-Sprache kann Polymorphismus mithilfe der „Interface“-Methode implementiert werden. Anders als bei herkömmlichen OOP-Sprachen wie Java wird die Implementierung der Schnittstelle durch das Schlüsselwort „implements“ definiert (z. B. das Schlüsselwort „implements“ in Java), das in der Go-Sprache implizit implementiert ist. Sie müssen lediglich einen Methodensatz definieren. Solange der Typ, der diesen Methodensatz implementiert, die Schnittstelle implementieren kann, ist es nicht erforderlich, explizit zu deklarieren, dass er die Schnittstelle implementiert.

Ein Beispiel für eine einfache Go-Schnittstelle ist wie folgt:

type Animal interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

type Cat struct{}

func (c Cat) Speak() string {
    return "Meow!"
}

func main() {
    var animal Animal = Dog{}
    fmt.Println(animal.Speak()) // 输出 Woof!
    animal = Cat{}
    fmt.Println(animal.Speak()) // 输出 Meow!
}

In diesem Beispiel definieren wir eine Schnittstelle namens Animal und darin eine Schnittstelle namens Speak-Methode. Wir haben außerdem zwei Typen erstellt, Dog und Cat, die beide die Animal-Schnittstelle implementieren. Schließlich nutzen wir die dynamische Natur der Tierschnittstelle, weisen sie Instanzen der Typen „Dog“ und „Cat“ zu und rufen die entsprechenden Speak-Methoden auf. Wie Sie sehen können, haben wir über die Schnittstelle einen einfachen Polymorphismus erreicht.

Zusammenfassung

Obwohl es in der Go-Sprache kein Klassenschlüsselwort gibt, können wir durch die Kombination von Strukturen und Methoden auch eine objektorientierte Programmierung erreichen, einschließlich Funktionen wie Kapselung, Vererbung und Polymorphismus. Und da es keine Komplexität der Klassen gibt, ist die objektorientierte Programmierung in der Go-Sprache prägnanter und flexibler. Gleichzeitig bietet die Go-Sprache auch Funktionen wie eine Schnittstelle und eine eingebettete Struktur zur Implementierung von Polymorphismus und Vererbung. Diese Funktionen ermöglichen es der Go-Sprache, die Einfachheit und Effizienz der Sprache beizubehalten, während OOP implementiert wird.

Das obige ist der detaillierte Inhalt vonGolang hat keine Klasse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!