So implementieren Sie objektorientierte Programmierkonzepte in Go

Objektorientierte Programmierung (OOP) ist ein Programmierparadigma, das auf Objekten als zentralem Konzept basiert. In OOP wird Code basierend auf Funktionalität formatiert, wodurch Codewartung, Abstraktion, Wiederverwendbarkeit, Effizienz und zahlreiche Funktionalitäten für das Objekt ermöglicht werden.

Das Objekt hat Attribute (Variablen), die seine Eigenschaften, Eigenschaften und Methoden (Funktionen) definieren, die die Aktionen (Prozeduren) und Verhaltensweisen des Objekts definieren.

Die objektorientierte Programmierung in Go unterscheidet sich von anderen Sprachen. Objektorientierte Konzepte werden in Go mithilfe von Strukturen, Schnittstellen und benutzerdefinierten Typen implementiert.

Anpassen von Typen in Go

Benutzerdefinierte Typen erleichtern das Gruppieren und Identifizieren ähnlichen Codes zur Wiederverwendung.

Der Code zum Deklarieren benutzerdefinierter Typen lautet:

Typ TypName Datentyp 

Beim Erstellen eines benutzerdefinierten Typs und Zuweisen einer Variablen können Sie den Typ mit überprüfen

reflektieren. Eine Art von() die eine Variable aufnimmt und den Typ der Variablen zurückgibt.

importieren("fmt"
 "reflektieren")
Typ zwei int// erstellt Typ "zwei"
Var Nummer zwei // Variable vom Typ "zwei"
fmt. Println (reflektieren. TypeOf (Zahl))

​​​

Das Anzahl Variable ist eine Art von zwei was eine ganze Zahl ist. Sie können weiter gehen, um weitere benutzerdefinierte Typen zu erstellen.

Strukturen in Go erstellen

Structs (Strukturen) sind die Blaupausen für die objektorientierte Programmierung in Go. Strukturen sind benutzerdefinierte Sammlungen von Feldern.

Eine Struktur kann eine Vielzahl von Datentypen enthalten, einschließlich zusammengesetzter Typen und Methoden.

Sie können eine Struktur mit dieser Syntax erstellen:

Typ Strukturname Struktur {
// etwas Code
}

Herkömmlicherweise werden Strukturnamen zur besseren Lesbarkeit großgeschrieben und in Kamelbuchstaben geschrieben.

Der Strukturtyp nimmt Feldnamen und Datentypen auf. Strukturen können jeden Go-Datentyp aufnehmen, einschließlich benutzerdefinierter Typen.

Typ Benutzer Struktur {
 Feld1 Schnur
 Feld2 int
 FeldKarte Karte[Schnur]int
}

Sie können einen Strukturtyp instanziieren, indem Sie die Struktur als Variable zuweisen.

Instanz := Benutzer{
// etwas Code
}

Die Strukturinstanz kann bei der Instanziierung mit Feldern gefüllt werden, wie sie bei der Initialisierung definiert wurden, oder auf null gesetzt werden.

Instanz := Benutzer{
 Feld1: "a Schnur Feld",
 Feld2: 10,
 FeldKarte: Karte[Schnur]int{},
 }

Zugriff auf Strukturelemente

Sie können auf die Felder einer Strukturinstanz zugreifen, indem Sie eine Punktnotation für das Feld verwenden.

fmt. Println("Zugriff auf ein Wertefeld", instance.field2)

Dies gibt die aus Feld2 der instanziierten Struct-Instanz.

Zuweisen von Methoden zu Strukturen

Funktionen (Methoden) werden Struct-Typen zugeordnet, indem ein Empfängername und der Struct-Name vor dem Funktionsnamen angegeben werden, wie in der folgenden Syntax gezeigt.

Funk(Empfänger StructName)Funktionsname() {
// etwas Code
}

Die Methode Funktionsname kann nur für den angegebenen Strukturtyp verwendet werden.

Implementierung der Vererbung in Go

Erbschaft ist die Fähigkeit von Objekten und Typen, auf Methoden und Attribute anderer Objekte zuzugreifen und diese zu verwenden. Go hat keine Vererbung als Funktion, aber Sie können Kompositionen verwenden. In Go beinhaltet die Komposition den Verweis auf eine Superstruktur (die zu vererbende Struktur) in einer Substruktur, indem der Name der Superstruktur an die Substruktur übergeben wird.

Verwenden Sie das obige Strukturbeispiel:

Typ Benutzer Struktur {
 Feld1 Schnur
 Feld2 int
 FeldKarte Karte[Schnur]int
}
Typ Benutzer2 Struktur {
 Benutzer
}

Durch das Passieren der Benutzer Strukturname in die Benutzer2 Struktur, die Benutzer2 struct kann auf alle Methoden und Attribute der zugreifen Benutzer struct bei der Instanziierung, außer dass Abstraktionstechniken verwendet werden.

Sohn := Benutzer2{
 Benutzer{
 Feld1: "Baby",
 Feld2: 0,
 FeldKarte: Null,
 },
 }
fmt. Println (Sohn.Feld2)

Das Sohn Die obige Variable ist eine Instanziierung der Benutzer2 Struktur. Wie im Beispiel zu sehen, die Sohn Variable kann auf Werte des Typs Benutzer zugreifen, diese instanziieren und sie verwenden.

Einkapseln von Typfeldern in Go

Kapselung, auch als „Information Hiding“ bekannt, ist eine Technik, die Methoden und Attribute eines Objekts zu Einheiten zu bündeln um die Nutzung und den Zugriff auf Ausnahmen zu beschränken (Freigabe von Lese-/Schreibrechten).

Die Kapselung wird in Go mithilfe von exportierten und nicht exportierten Bezeichnern in Paketen implementiert.

Exportierte Kennungen (Lesen und Schreiben)

Exportierte Identifikatoren werden aus ihren definierten Paketen exportiert und greifen auf andere Programme zu. Durch Großschreibung einer Feldkennung wird das Feld fo exportiert.

Typ Benutzer Struktur {
 Feld1 Schnur
 Feld2 int
 Feldkarte Karte[Schnur]int
}
Typ Benutzer2 Struktur {
 Benutzer
}

Nicht exportierte Kennungen (schreibgeschützt)

Nicht exportierte Bezeichner werden nicht aus dem definierten Paket exportiert und werden herkömmlicherweise in Kleinbuchstaben geschrieben.

Typ Benutzer Struktur {
 Feld1 Schnur
 Feld2 int
 FeldKarte Karte[Schnur]int
}
Typ Benutzer2 Struktur {
 Benutzer
}

Das Konzept der exportierten und nicht exportierten Bezeichner gilt auch für die Methoden eines Objekts.

Polymorphismus in Go

Polymorphismus ist eine Technik, die verwendet wird, um einem Objekt zwecks Flexibilität unterschiedliche Formen zu geben.

Go implementiert Polymorphie mithilfe von Schnittstellen. Schnittstellen sind benutzerdefinierte Typen, die zum Definieren von Methodensignaturen verwendet werden.

Schnittstellen deklarieren

Das Deklarieren von Schnittstellen ähnelt dem Deklarieren von Strukturen. Schnittstellen werden jedoch mit deklariert Schnittstelle Stichwort.

Typ Schnittstellenname Schnittstelle{
// einige Methoden
}

Schnittstellendeklarationen enthalten Methoden, die von Strukturtypen implementiert werden sollen.

Implementieren von Schnittstellen in Strukturen

Die Typen, die die Schnittstelle implementieren, müssen deklariert werden, wonach die Methoden des Typs die Schnittstelle implementieren.

// Die Schnittstelle
Typ Farbe Schnittstelle{
 Malen() Schnur
}
// Die Strukturen deklarieren
Typ Grün Struktur {
// ein strukturspezifischer Code
}
Typ Blau Struktur {
// ein bestimmter Code
}

Das obige Code-Snippet hat eine Farbe mit a deklarierte Schnittstelle Malen Methode, die von der implementiert werden soll Grün und Blau Strukturtypen.

Schnittstellen werden implementiert, indem Methoden Strukturtypen zugewiesen werden und die Methode dann nach der zu implementierenden Schnittstellenmethode benannt wird.

Funk(g Grün)Malen()Schnur {
Rückkehr "grün gestrichen"
}
Funk(b Blau)Malen()Schnur {
Rückkehr "blau gemalt"
}

Die Paint-Methode wird von Green- und Blue-Typen implementiert, die jetzt aufrufen und verwenden können Malen Methode.

Bürste := Grün{}
fmt. Println (pinsel. Malen())

„Grün gemalt“ wird auf der Konsole gedruckt, was bestätigt, dass die Schnittstelle erfolgreich implementiert wurde.

Abstrahieren von Feldern in Go

Abstraktion ist der Vorgang des Ausblendens unwichtiger Methoden und Attribute eines Typs, wodurch es einfacher wird, Teile des Programms vor anormaler, unbeabsichtigter Verwendung zu schützen.

Go hat keine Abstraktion auf Anhieb implementiert; Sie können sich jedoch durch die Implementierung von Abstraktion mithilfe von Schnittstellen vorarbeiten.

// Menschen können rennen
Typ Menschlich Schnittstelle {
 Lauf() Schnur
}
// Boy ist ein Mensch mit Beinen
Typ Junge Struktur {
 Beine Schnur
}
// eine Methode auf boy implementiert die run-Methode des Human Interface
Funk(h Junge)Lauf()Schnur {
Rückkehr h. Beine
}

Der obige Code erstellt a Menschlich Schnittstelle mit a Lauf Schnittstelle, die einen String zurückgibt. Das Junge Typ implementiert die Lauf Methode der Menschlich -Schnittstelle und gibt bei der Instanziierung einen String zurück.

Eine Möglichkeit, Abstraktion zu implementieren, besteht darin, eine Struktur dazu zu bringen, die Schnittstelle zu erben, deren Methoden abstrahiert werden sollen. Es gibt viele andere Ansätze, aber dieser ist der einfachste.

Typ Person Struktur {
 Name Schnur
 Alter int
 Status Mensch 
}
Funkhauptsächlich() {
 person1 := &Junge{Beine: "zwei Beine"}
 Person2 := &Person{ // Instanz einer Person
 Name: "Amina",
 Alter: 19,
 Status: Person1,
 }
 fmt. Println (Person. Status.run()) 
}

Das Person struct erbt die Menschlich -Schnittstelle und kann über die Variable auf alle ihre Methoden zugreifen Status Vererbung der Schnittstelle.

Bei der Instanziierung durch Referenz (unter Verwendung eines Zeigers) wird die Instanz der Person Struktur Person2 verweist auf eine Instanz von Junge Struktur Person1 und erhält Zugriff auf die Methoden.

Auf diese Weise können Sie bestimmte Methoden angeben, die vom Typ implementiert werden sollen.

OOP vs. funktionale Programmierung

Die objektorientierte Programmierung ist ein wichtiges Paradigma, da sie Ihnen mehr Kontrolle über Ihr Programm gibt und die Wiederverwendung von Code auf eine Weise fördert, wie es die funktionale Programmierung nicht tut.

Dies macht die funktionale Programmierung nicht zu einer schlechten Wahl, da die funktionale Programmierung für einige Anwendungsfälle hilfreich und besser sein kann.

Was ist objektorientierte Programmierung? Die Grundlagen in Laiensprache erklärt

Lesen Sie weiter

Über den Autor