Kuinka struct embedding (composition) toimii?

Question

Accepted Answer

Golla ei ole **periytymistä** — sen sijaan se käyttää **koostumusta** struct embeddingin kautta. Upottamalla yhden structin (tai interfacen) toisen sisälle, ulompi tyyppi saa sisemmän tyypin kentät ja metodit suoraan. Tämä on Gon vastaus koodin uudelleenkäyttöön, suosien "has-a" -koostumusta "is-a" -periytymisen sijaan.

## Structin upottaminen

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

Upottaminen (kirjoitetaan vain tyyppin nimi, ei kenttää nimeä) **edistää** upotetun tyypin kentät ja metodit ulompaan structiin — joten `d.Name` ja `d.Eat()` toimivat ikään kuin ne kuuluisivat `Dog`ille. Tämä näyttää periytymiseltä mutta on koostumus: `Dog` *omistaa* `Animal`in.

## Edistettyjen metodien ohittaminen

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

Uloimpityyppi voi määritellä saman nimisen metodin "ohittaakseen" (varjostaa) edistetyn; voit silti saada eksplisiittisesti upotetun version.

## Interfacejen upottaminen (hyvin yleistä)

```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-upottaminen koostaa pieniä interfaceja suuremmiksi — käytetään koko standardikirjastossa.

## Koostumus periytymisen sijaan — Gon filosofia

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

## Miksi se on tärkeää

Struct embedding on Gon erityinen mekanismi **koodin uudelleenkäyttöä ja koostumusta** varten, korvaten useimpissa OOP-kielissä löytyvän periytymisen.

Sen ymmärtäminen on olennaista, koska se on kuinka Go saavuttaa uudelleenkäyttöä (edistää upotettujen kenttien/metodien niin että ulompi tyyppi "perii" käyttäytymisen koostumuksen kautta) samalla kun se tietoisesti välttää periytymisen tunnettuja ongelmia (hauraita perusluokkia, syvät jäykät hierarkiat, tiukkaa kytkettyä).

Se ilmentää laajalti hyväksyttyä periaatetta **"koostumus periytymisen sijaan."** Upottaminen esiintyy jatkuvasti — structien upottaminen uudelleenkäyttöä varten, interfacejen upottaminen suurempien sopimusten rakentamiseksi (kuten `io.ReadWriter`) ja upottaminen mixin-tyyliselle käyttäytymiselle.

Se, että Go:lla ei ole periytymistä ja että upottaminen on sen kompositorinen vaihtoehto — plus metodien ennakkomaksun ja varjostamisen säännöt — on perustavanlaatuista idiomatisen Gon lukemiselle ja suunnittelulle, ja yleinen haastattelun aihe, koska se eroaa luokkapohjaisista kielistä.