Kako funkcionira struct embedding (kompozicija)?

Question

Accepted Answer

Go **nema naslijeđivanja** — umjesto toga koristi **kompoziciju** kroz struct embedding. Ugniježđivanjem jedne strukture (ili sučelja) u drugu, vanjski tip dobiva polja i metode unutarnjeg tipa direktno. Ovo je Gojin odgovor na ponovno korištenje koda, favorizirajući "has-a" kompoziciju umjesto "is-a" naslijeđivanja.

## Ugniježđivanje 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
```

Ugniježđivanje (pisanje samo imena tipa, bez imena polja) **promovira** polja i metode ugniježđenog tipa vanjskoj strukturi — tako da `d.Name` i `d.Eat()` rade kao da pripadaju `Dog`. Ovo izgleda kao naslijeđivanje ali je kompozicija: `Dog` *ima* `Animal`.

## Zamjena promoviraних metoda

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

Vanjski tip može definirati metodu s istim imenom da "zamijeni" (zasjeni) promoviranu; ipak možete pristupiti ugniježđenoj verziji eksplicitno.

## Ugniježđivanje sučelja (vrlo često)

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

Ugniježđivanje sučelja sastoji mala sučelja u veća — koristi se cijelom standardnom bibliotekom.

## Kompozicija umjesto naslijeđivanja — Gojeva 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
```

## Zašto je važno

Struct embedding je Goin distinktivni mehanizam za **ponovno korištenje koda i kompoziciju**, zamjenjujući naslijeđivanje pronađeno u većini OOP jezika.

Razumijevanje je bitno jer je to kako Go postiže ponovno korištenje (promoviranje ugniježđenih polja/metoda tako da vanjski tip "nasljeđuje" ponašanje kroz kompoziciju) dok namjerno izbjegava poznate probleme naslijeđivanja (krhke bazne klase, duboke krute hijerarhije, čvrsto povezivanje).

Utjelovljuje široko prihvaćeni princip **"kompozicija umjesto naslijeđivanja."** Embedding se pojavljuje svugdje — ugniježđivanje struktura za ponovno korištenje, ugniježđivanje sučelja za gradnju većih ugovora (kao `io.ReadWriter`), i ugniježđivanje za ponašanje mixin stila.

Prepoznavanje da Go nema naslijeđivanja i da je embedding njegova kompozicijska alternativa — plus pravila promovacije metoda i zasjenjivanja — fundamentalno je za čitanje i dizajn idiomatskog Goa, i česta je tema intervjua s obzirom kako se razlikuje od jezika temeljenih na klasama.