Hogyan működik a struct beágyazás (composition)?

Question

Accepted Answer

A Go-ban **nincs öröklődés** — helyette a **composition** szerveződik struct beágyazáson keresztül. Egy struct (vagy interface) beágyazásával egy másikba, a külső típus közvetlenül megkapja a belső típus mezőit és metódusait. Ez a Go válasza a kód újrafelhasználására, a "has-a" compositiont előnyben részesítve a "is-a" öröklődéssel szemben.

## Struct beágyazása

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

A beágyazás (csak a típus nevét írva, nincs mezőnév) **promóválja** a beágyazott típus mezőit és metódusait a külső structba — így a `d.Name` és a `d.Eat()` úgy működnek, mintha a `Dog`-hoz tartoznának. Ez öröklődésnek tűnhet, de composition: a `Dog` *rendelkezik egy* `Animal`-lal.

## Promovált metódusok felülírása

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

A külső típus definiálhat egy azonos nevű metódust a promovált metódus "felülírásához" (árnyékolásához); a beágyazott verzió explicit módon még elérhető.

## Interfészek beágyazása (nagyon gyakori)

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

Az interfész beágyazás kis interfészeket összetárol nagyobbakká — az összes standard library-ban használt.

## Composition helyett öröklődés — a Go filozófia

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

## Miért számít

A struct beágyazás a Go-nak a **kód újrafelhasználás és composition** sajátos mechanizmusa, amely helyettesíti a legtöbb OOP nyelvben talált öröklődést.

Annak megértése alapvető, mert így éri el a Go az újrafelhasználást (beágyazott mezők/metódusok promóválása, így a külső típus "örökli" a viselkedést compositionon keresztül), miközben szándékosan elkerüli az öröklődés jól ismert problémáit (törékeny alaposztályok, mély merev hierarchiák, szoros csatolás).

Embodied az általánosan támogatott elv: **"composition helyett öröklődés."** A beágyazás rendszeresen megjelenik — structok beágyazása az újrafelhasználásért, interfészek beágyazása nagyobb szerződések építéséhez (mint az `io.ReadWriter`), és beágyazás mixin-stílusú viselkedéshez.

Annak felismerése, hogy a Go-ban nincs öröklődés és a beágyazás az ő összetételes alternatívája — plusz a metódus-promóciós és árnyékolási szabályok — alapvető az idiomatikus Go olvasásához és tervezéséhez, és gyakori interjú-téma, mivel eltér az osztály-alapú nyelvektől.