Как работает встраивание структур (композиция)?

Question

Accepted Answer

Go не имеет **наследования** — вместо этого он использует **композицию** через встраивание структур. Встраивая одну структуру (или интерфейс) внутрь другой, внешний тип получает поля и методы внутреннего типа напрямую. Это ответ Go на повторное использование кода, отдавая предпочтение композиции "has-a" вместо наследования "is-a".

## Встраивание структуры

```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.Name` и `d.Eat()` работают так, как если бы они принадлежали `Dog`. Это выглядит как наследование, но это композиция: `Dog` *имеет* `Animal`.

## Переопределение повышенных методов

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

Внешний тип может определить метод с тем же именем, чтобы "переопределить" (затенить) повышенный метод; вы все еще можете получить доступ к встраиваемой версии явно.

## Встраивание интерфейсов (очень распространено)

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

Встраивание интерфейса объединяет маленькие интерфейсы в более крупные — используется по всей стандартной библиотеке.

## Композиция вместо наследования — философия 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
```

## Почему это важно

Встраивание структур — это отличительный механизм Go для **повторного использования кода и композиции**, заменяющий наследование, встречающееся в большинстве ООП-языков.

Понимание его критически важно, потому что именно так Go достигает повторного использования (повышение встраиваемых полей/методов, так что внешний тип "наследует" поведение через композицию), одновременно намеренно избегая известных проблем наследования (хрупкие базовые классы, глубокие жесткие иерархии, плотная связанность).

Это воплощает широко поддерживаемый принцип **"композиция вместо наследования"**. Встраивание появляется постоянно — встраивание структур для повторного использования, встраивание интерфейсов для создания более крупных контрактов (как `io.ReadWriter`), и встраивание для поведения в стиле миксинов.

Разумение того, что Go не имеет наследования и что встраивание является его композиционной альтернативой — плюс правила повышения методов и затенения — фундаментально для чтения и проектирования идиоматичного Go, и это частая тема интервью, учитывая, чем оно отличается от языков на основе классов.