Wie funktioniert struct embedding (composition)?

Question

Accepted Answer

Go hat **keine Vererbung** — stattdessen verwendet es **Composition** über struct embedding. Durch das Einbetten einer Struktur (oder eines Interfaces) in eine andere erhält der äußere Typ die Felder und Methoden des inneren Typs direkt. Dies ist Go's Antwort auf Code-Wiederverwendung, die "hat-ein"-Komposition "ist-ein"-Vererbung bevorzugt.

## Einbetten einer Struktur

```go
type Animal struct {
    Name string
}
func (a Animal) Eat() string {
    return a.Name + " is eating"
}

type Dog struct {
    Animal    // EMBEDDED — no field name, just the type → composition
    Breed string
}

d := Dog{
    Animal: Animal{Name: "Rex"},
    Breed:  "Lab",
}

// Dog gets Animal's fields and methods PROMOTED — accessed directly
fmt.Println(d.Name)     // "Rex" — promoted from the embedded Animal
fmt.Println(d.Eat())    // "Rex is eating" — Animal's method, called on Dog
```

Einbetten (nur den Typnamen schreiben, kein Feldname) **fördert** die Felder und Methoden des eingebetteten Typs zur äußeren Struktur — sodass `d.Name` und `d.Eat()` funktionieren, als gehörten sie zu `Dog`. Dies sieht wie Vererbung aus, ist aber Komposition: `Dog` *hat ein* `Animal`.

## Überschreiben gefördeter Methoden

```go
func (d Dog) Eat() string {        // Dog defines its OWN Eat()
    return d.Name + " the dog eats noisily"
}
d.Eat()         // calls Dog's Eat (the outer one shadows the embedded one)
d.Animal.Eat()  // explicitly call the embedded Animal's Eat if needed
```

Der äußere Typ kann eine Methode mit gleichem Namen definieren, um die geförderte zu "überlagern"; Sie können immer noch auf die eingebettete Version explizit zugreifen.

## Einbetten von Interfaces (sehr häufig)

```go
// embed interfaces to compose larger ones
type Reader interface { Read(p []byte) (int, error) }
type Writer interface { Write(p []byte) (int, error) }

type ReadWriter interface {   // composed from both via embedding
    Reader
    Writer
}
// (this is exactly how io.ReadWriter is defined in the standard library)
```

Interface embedding komponiert kleine Interfaces zu größeren — wird in der gesamten Standardbibliothek verwendet.

## Komposition über Vererbung — Go Philosophie

```text
No class hierarchies, no "extends". Instead:
  ✓ Embed to reuse fields/methods (has-a)
  ✓ Embed interfaces to compose behavior contracts
  ✓ Avoids the fragility, deep hierarchies, and tight coupling of inheritance
```

## Warum es wichtig ist

Struct embedding ist Go's Unterscheidungsmerkmal für **Code-Wiederverwendung und Komposition**, das die in den meisten OOP-Sprachen vorkommende Vererbung ersetzt.

Das Verständnis ist wesentlich, weil es zeigt, wie Go Wiederverwendung erreicht (fördert eingebettete Felder/Methoden, sodass der äußere Typ Verhalten durch Komposition "erbt"), während es bewusst die bekannten Probleme der Vererbung vermeidet (fragile Basisklassen, tiefe starre Hierarchien, enge Kopplung).

Es verkörpert das weit verbreitete Prinzip **"Komposition über Vererbung."** Embedding erscheint ständig — Einbetten von Strukturen zur Wiederverwendung, Einbetten von Interfaces zum Aufbau größerer Verträge (wie `io.ReadWriter`) und Einbetten für Mixin-ähnliches Verhalten.

Zu erkennen, dass Go keine Vererbung hat und dass embedding seine Kompositions-Alternative ist — plus die Methoden-Förderungs- und Schattenbildungsregeln — ist grundlegend zum Lesen und Gestalten von idiomatischem Go und ein häufiges Interviewthema angesichts der Unterschiede zu klassenbasierten Sprachen.