Kako deluje vgradnja struktur (komposicija)?

Question

Accepted Answer

Go **nima dedovanja** — namesto tega uporablja **komposicijo** prek vgradnje struktur. Z vgradnjo ene strukture (ali vmesnika) v drugo struktura zunanja vrsta pridobi polja in metode notranje vrste neposredno. To je Gov odgovor na ponovno uporabo kode, ki daje prednost komposiciji »ima-a« pred dedovanjem »je-a".

## Vgradnja strukture

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

Vgradnja (pisanje samo imena vrste, brez imena polja) **promovira** polja in metode vgrajene vrste na zunanjo strukturo — tako da `d.Name` in `d.Eat()` delujejo, kot da bi pripadali `Dog`. To je videti kot dedovanje, toda je komposicija: `Dog` *ima* `Animal`.

## Preglasovanje promovanih 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
```

Zunanja vrsta lahko definira metodo z istim imenom, da »preglasi« (zasenči) promovano; do vgrajene verzije se lahko še vedno dostopa eksplicitno.

## Vgradnja vmesnikov (zelo pogosta)

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

Vgradnja vmesnika sestavi majhne vmesnike v večje — uporablja se v celotni standardni knjižnici.

## Komposicija pred dedovanjem — Gova filozofija

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

## Zakaj je to pomembno

Vgradnja struktur je Gov značilen mehanizem za **ponovno uporabo in komposicijo kode**, ki nadomešča dedovanje, ki se pojavljajo v večini objektno usmerenih jezikov.

Razumevanje je bistveno, ker je to način, kako Go dosega ponovno uporabo (promoviranje vgrajenih polj/metod, tako da zunanja vrsta »podeduje« obnašanje prek komposicije) in hkrati namerno izogiba dobro znanim težavam dedovanja (krhke bazne razrede, globoke toge hierarhije, tesno povezanost).

Vsebuje splošno podprto načelo **»komposicija pred dedovanjem.«** Vgradnja se pojavljuje nenehno — vgradnja struktur za ponovno uporabo, vgradnja vmesnikov za izgradnjo večjih pogodb (kot `io.ReadWriter`) in vgradnja za obnašanje tipa mixin.

Ugotavljanje, da Go nima dedovanja in da je vgradnja njegova kompozicijska alternativa — skupaj s pravili promovacije in zasenčitve metod — je temeljno za branje in oblikovanje idiomatičnega Goja, in pogosta tema na intervjujih, saj se razlikuje od jezikov na osnovi razredov.