Jak działa osadzanie struktur (composition)?

Question

Accepted Answer

Go **nie ma dziedziczenia** — zamiast tego używa **composition** poprzez osadzanie struktur. Osadzając jedną strukturę (lub interfejs) wewnątrz innej, zewnętrzny typ zyskuje pola i metody wewnętrznego typu bezpośrednio. To jest rozwiązanie Go na temat ponownego użytku kodu, preferując skład "has-a" zamiast dziedziczenia "is-a".

## Osadzanie struktury

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

Osadzanie (pisanie samej nazwy typu, bez nazwy pola) **promuje** pola i metody osadzonego typu do zewnętrznej struktury — więc `d.Name` i `d.Eat()` działają tak, jakby należały do `Dog`. To wygląda jak dziedziczenie, ale jest to composition: `Dog` *ma* `Animal`.

## Przesłanianie promowanych metod

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

Zewnętrzny typ może zdefiniować metodę o tej samej nazwie, aby "przesłonić" (shadow) promowaną; nadal możesz bezpośrednio dotrzeć do osadzonej wersji.

## Osadzanie interfejsów (bardzo powszechne)

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

Osadzanie interfejsów komponuje małe interfejsy w większe — używane w całej bibliotece standardowej.

## Composition zamiast dziedziczenia — 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
```

## Dlaczego to ważne

Osadzanie struktur to charakterystyczny mechanizm Go do **ponownego użytku kodu i composition**, zastępujący dziedziczenie znalezione w większości języków OOP.

Zrozumienie go jest istotne, ponieważ to jest sposób, w jaki Go osiąga ponowne użycie (promując osadzone pola/metody, aby zewnętrzny typ "odziedziczył" zachowanie poprzez composition) przy jednoczesnym celowym unikaniu dobrze znanych problemów z dziedziczeniem (kruche klasy bazowe, głębokie sztywne hierarchie, ścisłe powiązania).

Utklenkuje szeroko aprobowaną zasadę **"composition over inheritance."** Osadzanie pojawia się wszędzie — osadzanie struktur do ponownego użytku, osadzanie interfejsów do budowania większych kontraktów (jak `io.ReadWriter`), i osadzanie dla zachowania w stylu mixin.

Rozpoznanie, że Go nie ma dziedziczenia i że osadzanie jest jego alternatywą compositional — plus zasady promocji metod i przesłaniania — jest fundamentalne dla czytania i projektowania idiomatycznego Go, i jest częstym tematem rozmów kwalifikacyjnych ze względu na to, jak różni się od języków opartych na klasach.