Kaip veikia struct įdėjimas (sudėtis)?

Question

Accepted Answer

Go **neturi paveldimumo** — vietoje to naudoja **sudėtį** per struct įdėjimą. Įdėjus vieną struct (arba sąsają) į kitą, išorinė tipo gauna vidinio tipo laukus ir metodus tiesiogiai. Tai Go atsakas į kodo pakartotinį naudojimą, teikiant pirmenybę "turi" sudėčiai prieš "yra" paveldimumą.

## Struct įdėjimas

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

Įdėjimas (rašant tik tipo pavadinimą, be lauko pavadinimo) **skatina** įdėto tipo laukus ir metodus išoriniam struct — taigi `d.Name` ir `d.Eat()` veikia tarsi priklauso `Dog`. Tai atrodo kaip paveldimumas, bet tai yra sudėtis: `Dog` *turi* `Animal`.

## Skatintų metodų perrašymas

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

Išorinė tipo gali apibrėžti metodą su tuo pačiu pavadinimu, kad "nušlametų" skaitintą; vis tiek galite pasiekti įdėtą versiją aiškiai.

## Sąsajų įdėjimas (labai dažnas)

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

Sąsajų įdėjimas suderina mažas sąsajas į didesnes — naudojama visoje standartinėje bibliotekoje.

## Sudėtis virš paveldimumo — Go filosofija

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

## Kodėl tai svarbu

Struct įdėjimas yra Go išskirtinis **kodo pakartotinio naudojimo ir sudėties** mechanizmas, keičiantis paveldimumą, randamą daugelyje OOP kalbų.

Jo suprasti yra būtina, nes tai yra, kaip Go pasiekia pakartotinį naudojimą (skatindamas įdėtus laukus/metodus, kad išorinė tipo "paveldėtų" elgesį per sudėtį), kartu iš esmės išvengiant žinomų paveldimumo problemų (trapios bazės klasės, gilios standžios hierarchijos, stipri sąsaja).

Ji įkūnija plačiai pripažintą principą **"sudėtis virš paveldimumo."** Įdėjimas pasirodo nuolat — struct įdėjimas pakartotiniam naudojimui, sąsajų įdėjimas didesnėms sutartims kurti (pavyzdžiui, `io.ReadWriter`), ir įdėjimas mixin stiliaus elgesiui.

Suprasti, kad Go neturi paveldimumo ir kad įdėjimas yra jo sudėties alternatyva — plius metodo skatinimo ir šešėlio taisyklės — yra pagrindinė skaityti ir kurti idiomatinį Go, ir dažna pokalbio tema atsižvelgiant į skirtumą nuo klasėmis pagrįstų kalbų.