Jak funguje vkládání struktur (composition)?

Question

Accepted Answer

Go nemá **dědičnost** — místo toho používá **složení** prostřednictvím vkládání struktur. Vložením jedné struktury (nebo rozhraní) do druhé získá vnější typ pole a metody vnitřního typu přímo. To je Go odpověď na opakované použití kódu, upřednostňující "má-a" composici před "je-a" dědičností.

## Vkládání struktury

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

Vkládání (psaní pouze názvu typu, bez názvu pole) **podporuje** pole a metody vloženého typu na vnější strukturu — takže `d.Name` a `d.Eat()` fungují, jako by patřily `Dog`. Vypadá to jako dědičnost, ale je to složení: `Dog` *má* `Animal`.

## Přepsání propagovaných metod

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

Vnější typ může definovat metodu se stejným jménem, aby "přepsal" (stínoval) propagovanou; můžete stále explicitně dosáhnout vložené verze.

## Vkládání rozhraní (velmi běžné)

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

Vkládání rozhraní skládá malá rozhraní do větších — používá se v celé standardní knihovně.

## Složení namísto dědičnosti — Go filozofie

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

## Proč na tom záleží

Vkládání struktur je Go zásadní mechanismus **pro opakované použití kódu a složení**, které nahrazuje dědičnost nacházející se ve většině OOP jazyků.

Jeho pochopení je nezbytné, protože je to, jak Go dosahuje opakovaného použití (propagace vložených polí/metod tak, aby vnější typ "dědil" chování prostřednictvím složení) a zároveň úmyslně vyhýbá se dobře známým problémům dědičnosti (křehké základní třídy, hluboké rigidní hierarchie, těsná vazba).

Vtěluje všeobecně podporovaný princip **"složení namísto dědičnosti."** Vkládání se vyskytuje neustále — vkládání struktur pro opakované použití, vkládání rozhraní pro vytváření větších kontraktů (jako `io.ReadWriter`) a vkládání pro chování ve stylu mixin.

Rozpoznání, že Go nemá dědičnost a že vkládání je jeho композiční alternativou — plus pravidla propagace a stínování metod — je zásadní pro čtení a navrhování idiomatic Go a běžné téma v pohovorech vzhledem k tomu, jak se liší od jazyků na bázi tříd.