Wie wird Vererbung in Golang implementiert?

In Go gibt es keine traditionelle Klassenvererbung wie in Java oder C++. Stattdessen werden zwei Mechanismen verwendet:

1. Embedding (Einbettung):

   • Das Einbetten ermöglicht es, eine Struktur oder einen Typ in eine andere zu integrieren.
   • Der eingebettete Typ "überträgt" seine Felder und Methoden an den einbettenden Typ.
   • Der Zugriff auf Felder und Methoden des eingebetteten Typs erfolgt direkt, als wären sie im einbettenden Typ definiert.
   • Dies imitiert Komposition, aber mit einer bequemeren Zugriffssyntax, ähnlich wie bei Vererbung.

   package main
   
   import "fmt"
   
   type Engine struct {
       Type string
   }
   
   func (e Engine) Start() {
       fmt.Println(e.Type, "Motor gestartet")
   }
   
   type Car struct {
       Engine // Einbettung der Engine-Struktur
       Model  string
   }
   
   func main() {
       car := Car{
           Engine: Engine{Type: "V8"},
           Model:  "Mustang",
       }
   
       // Direkter Zugriff auf Felder und Methoden der eingebetteten Struktur
       fmt.Println("Modell des Autos:", car.Model)
       car.Start() // Aufruf der Methode der eingebetteten Struktur
   }
   

2. Interfaces:

   • Interfaces definieren eine Menge von Methoden, die ein Typ implementieren muss.
   • Sie definieren "Verhalten" und nicht Datenstrukturen.
   • Der Typ muss nicht explizit deklarieren, dass er das Interface implementiert; es reicht, alle Methoden zu implementieren.
   • Interfaces ermöglichen Polymorphismus.

   package main
   
   import "fmt"
   
   type Speaker interface {
       Speak()
   }
   
   type Dog struct {
       Name string
   }
   
   func (d Dog) Speak() {
       fmt.Println(d.Name, "sagt Woof!")
   }
   
   type Cat struct {
       Name string
   }
   
   func (c Cat) Speak() {
       fmt.Println(c.Name, "sagt Miau!")
   }
   
   func main() {
       animals := []Speaker{
           Dog{Name: "Buddy"},
           Cat{Name: "Whiskers"},
       }
   
       for _, animal := range animals {
           animal.Speak() // Polymorpher Aufruf der Methode Speak
       }
   }
   

Die Kombination aus Einbettung und Interfaces ermöglicht es Go, Flexibilität und Wiederverwendbarkeit des Codes zu erreichen, ohne die Komplexitäten und Probleme, die mit traditionellem Erben verbunden sind (z.B. das "Diamant"-Problem). In Go werden Komposition und Interfaces gegenüber Vererbungshierarchien bevorzugt.