Wie ist das objektorientierte Modell in Go aufgebaut…

In Go gibt es kein traditionelles objektorientiertes Modell mit einer tiefen Klassen-Hierarchie. Stattdessen werden verwendet:

Structs: Definieren Datenfelder, ähnlich wie Klassen ohne Methoden.
```
type Person struct {
    Name string
    Age  int
}
```
Methoden: Funktionen, die an eine bestimmte Struktur gebunden sind. Sie werden getrennt von der Struktur definiert.
```
func (p Person) Greet() string {
    return "Hallo, mein Name ist " + p.Name
}

func (p *Person) CelebrateBirthday() {
    p.Age++
}
```
- Methoden mit Wert-Receiver (z.B. (p Person)) arbeiten mit einer Kopie der Struktur.
- Methoden mit Zeiger-Receiver (z.B. (p *Person)) arbeiten mit dem Original, was Änderungen an den Feldern ermöglicht.
Interfaces: Mengen von Methodensignaturen. Typen, die alle Methoden eines Interfaces implementieren, erfüllen dieses implizit. Das ist die Grundlage des Polymorphismus in Go.
```
type Greeter interface {
    Greet() string
}

// Person implementiert implizit Greeter
```

Komposition (Eingebettete Strukturen): Anstelle von Vererbung kann eine Struktur eine andere Struktur einbetten, um auf deren Felder und Methoden zuzugreifen.

type Employee struct {
    Person // Eingebettete Struktur
    ID     string
}

func (e Employee) GetID() string {
    return e.ID
}

Eingebettete Felder und Methoden sind direkt zugänglich:

e := Employee{
    Person: Person{Name: "Alice", Age: 30},
    ID:     "E123",
}
fmt.Println(e.Name)     // Zugriff auf das Feld Name über die eingebettete Person
fmt.Println(e.Greet())  // Aufruf der Methode Greet über die eingebettete Person
fmt.Println(e.GetID())  // Aufruf der Methode Employee

Das objektorientierte Modell in Go basiert also auf der Komposition von Strukturen und dem Verhalten, das durch Interfaces definiert wird, und nicht auf einer klassischen Klassen-Hierarchie.

Wie ist das objektorientierte Modell in Go aufgebaut?