Hoe werkt struct embedding (compositie)?

Question

Accepted Answer

Go heeft **geen erfenis** — in plaats daarvan gebruikt het **compositie** via struct embedding. Door een struct (of interface) in een ander in te bedden, krijgt het buitenste type de velden en methoden van het binnenste type rechtstreeks. Dit is Go's antwoord op codeherhaling, waarbij "has-a" compositie de voorkeur krijgt boven "is-a" erfenis.

## Inbedding van een struct

```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
```

Inbedding (alleen de typenaam schrijven, geen veldnaam) **promoveert** de velden en methoden van het ingebedde type naar de buitenste struct — dus `d.Name` en `d.Eat()` werken alsof ze bij `Dog` horen. Dit ziet er uit als erfenis maar is compositie: `Dog` *heeft een* `Animal`.

## Gepromoveerde methoden overschrijven

```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
```

Het buitenste type kan een methode met dezelfde naam definiëren om de gepromoveerde methode te "overschaduwen"; je kunt de ingebedde versie nog steeds expliciet bereiken.

## Interfaces inbedden (zeer gebruikelijk)

```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 componeert kleine interfaces tot grotere — gebruikt in heel de standaardbibliotheek.

## Compositie boven erfenis — de Go-filosofie

```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
```

## Waarom het belangrijk is

Struct embedding is Go's onderscheidende mechanisme voor **codeherhaling en compositie**, en vervangt de erfenis die in de meeste OOP-talen voorkomt.

Er begrip van hebben is essentieel omdat het hoe Go hergebruik bereikt (gepromoveerde ingebedde velden/methoden zodat het buitenste type gedrag "erft" via compositie) terwijl het opzettelijk de welbekende problemen van erfenis vermijdt (fragiele basisklassen, diepe rigide hiërarchieën, sterke koppeling).

Het belichaamt het algemeen ondersteunde principe **"compositie boven erfenis."** Embedding verschijnt voortdurend — inbedding van structs voor hergebruik, inbedding van interfaces om grotere contracten op te bouwen (zoals `io.ReadWriter`), en inbedding voor mixin-achtig gedrag.

Het herkennen dat Go geen erfenis heeft en dat embedding zijn compositie-alternatief is — plus de regels voor methode-promotie en overschaduwing — is fundamenteel voor het lezen en ontwerpen van idiomatische Go, en een veelvoorkomend interviewonderwerp gezien het verschil met op klassen gebaseerde talen.