Cum funcționează embedding-ul de structuri (compoziție)?

Question

Accepted Answer

Go **nu are moștenire** — în schimb folosește **compoziție** prin embedding de structuri. Prin încapsularea unei structuri (sau interfață) în altă structură, tipul exterior dobândește direct câmpurile și metodele tipului interior. Aceasta este răspunsul Go la reutilizarea codului, favorizând compoziția "has-a" în locul moștenirii "is-a".

## Embedding de structuri

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

Embedding-ul (scrierea doar a numelui tipului, fără nume de câmp) **promovează** câmpurile și metodele tipului încapsulat către structura exterioară — deci `d.Name` și `d.Eat()` funcționează ca și cum ar aparține lui `Dog`. Aceasta arată ca moștenire, dar este compoziție: `Dog` *are un* `Animal`.

## Suprascrierea metodelor promovate

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

Tipul exterior poate defini o metodă cu același nume pentru a "suprascrie" (umbri) cea promovată; poți totuși accesa versiunea încapsulată în mod explicit.

## Embedding de interfețe (foarte obișnuit)

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

Embedding-ul de interfață compune interfețe mici în interfețe mai mari — utilizat în întreaga bibliotecă standard.

## Compoziție peste moștenire — filozofia Go

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

## De ce contează

Embedding-ul de structuri este mecanismul caracteristic al Go pentru **reutilizarea și compoziția codului**, înlocuind moștenirea găsită în majoritatea limbajelor OOP.

Înțelegerea sa este esențială deoarece aceasta este modul în care Go realizează reutilizarea (promovând câmpuri/metode încapsulate, deci tipul exterior "moștenește" comportament prin compoziție), evitând deliberat problemele binecunoscute ale moștenirii (clase de bază fragile, ierarhii rigide și adânci, cuplare strânsă).

Embodied principiul larg endorsed **"compoziție peste moștenire."** Embedding apare constant — embedding de structuri pentru reutilizare, embedding de interfețe pentru a construi contracte mai mari (cum ar fi `io.ReadWriter`), și embedding pentru comportament de tip mixin.

Recunoașterea faptului că Go nu are moștenire și că embedding-ul este alternativa sa de compoziție — plus regulile de promovare și umbrire a metodelor — este fundamental pentru citirea și proiectarea codului Go idiomativ, și un subiect frecvent în interviuri, având în vedere cum diferă de limbajele cu clase.