> В чем разница наследования в Go и классического наследования (Go)

Короткий ответ

В Go нет классического наследования в смысле ООП - вместо него используется композиция и встраивание (embedding) типов. Классическое наследование предполагает иерархию классов с наследованием поведения и состояния, тогда как Go предлагает повторное использование через встраивание структур и интерфейсы для полиморфизма. Это принципиально другой подход: вы не получаете автоматически методы родителя как часть дочернего типа, а делегируете их через встроенное поле.

Подробное объяснение

Классическое наследование (Java, C++, Python) строится на отношении "is-a": класс-наследник полностью включает состояние и поведение родителя, может переопределять методы, имеет доступ к protected-полям, и поддерживает восходящее приведение типов. Иерархия фиксируется на этапе компиляции, и изменение родителя может сломать всех наследников.

В Go используется встраивание (embedding) - отношение "has-a" с синтаксическим сахаром. Когда вы встраиваете структуру Base в Derived, поля и методы Base становятся доступны через Derived, но это не наследование в классическом смысле:

• Нет переопределения методов - если Derived определяет метод с тем же именем, он просто затеняет метод Base, но не вызывается через интерфейс, ожидающий Base.
• Нет доступа к приватным полям - встраивание работает только с экспортируемыми полями и методами.
• Нет виртуальных методов - вызов метода на Derived не может динамически диспетчеризоваться к переопределённой версии из Base.
• Полиморфизм достигается через интерфейсы, а не через наследование типов. Тип удовлетворяет интерфейсу неявно, по структуре методов.

Ключевое различие: в классическом ООП наследование создаёт жёсткую связь между типами, а в Go композиция даёт гибкость без глубоких иерархий. Встраивание - это просто сокращение для делегирования: Derived содержит поле Base и автоматически проксирует к нему вызовы.

На практике

На практике это означает:

• Проектирование через интерфейсы - вместо абстрактных классов вы определяете интерфейсы с минимальным набором методов, и любые типы, реализующие их, взаимозаменяемы.
• Композиция вместо наследования - вы строите сложные типы из простых, встраивая их, а не создавая глубокие цепочки наследования.
• Отсутствие проблемы ромбовидного наследования - в Go нет множественного наследования, но можно встроить несколько структур, и конфликты имён решаются явным обращением к полю.
• Изменение поведения через обёртки - если нужно расширить функциональность, вы создаёте новую структуру, встраиваете исходную и добавляете свои методы, но не можете переопределить существующие.

Типичный паттерн - встраивание для переиспользования реализации, но при этом интерфейсы определяют контракт. Например, io.Reader и io.Writer - это интерфейсы, а bytes.Buffer и os.File - независимые реализации.

Пример кода

GO
type Base struct {
    Name string
}

func (b *Base) Greet() string {
    return "Hello, " + b.Name
}

type Derived struct {
    Base  // встраивание
    Age   int
}

func (d *Derived) Greet() string {
    return fmt.Sprintf("Hi, %s (age %d)", d.Name, d.Age)
}

// Использование
d := Derived{Base: Base{Name: "Alice"}, Age: 30}

// Доступ к полю встроенной структуры
fmt.Println(d.Name) // "Alice"

// Вызов метода Derived - затенение
fmt.Println(d.Greet()) // "Hi, Alice (age 30)"

// Но нельзя использовать Derived там, где ожидается *Base
// var b *Base = &d // Ошибка компиляции

// Полиморфизм через интерфейс
type Greeter interface {
    Greet() string
}

var g Greeter = &d // работает, так как Derived имеет метод Greet

Как отвечать на собеседовании

Начните с чёткого тезиса: в Go нет наследования, есть встраивание и интерфейсы. Затем объясните разницу на уровне механики: встраивание - это композиция с автоматическим делегированием, а не иерархия типов. Подчеркните, что полиморфизм достигается через интерфейсы, а не через наследование. Приведите пример, где классическое наследование создало бы проблемы (например, изменение родительского класса ломает наследников), и покажите, как в Go это решается через композицию. Упомяните, что отсутствие переопределения методов - это осознанное решение для простоты и предсказуемости.

Что проверяет интервьюер

Интервьюер проверяет:

• понимание фундаментальных отличий между наследованием и композицией;
• знание синтаксиса встраивания и его ограничений;
• умение объяснить, как работает полиморфизм в Go через интерфейсы;
• способность рассуждать о trade-off между жёсткой иерархией и гибкой композицией;
• понимание, почему в Go выбрали такой подход (простота, отсутствие скрытых зависимостей).

Типичные ошибки

• Утверждение, что встраивание - это то же самое, что наследование, просто с другим синтаксисом.
• Попытка переопределить метод встроенной структуры и ожидание виртуальной диспетчеризации.
• Использование встраивания для создания глубоких иерархий, что противоречит философии Go.
• Путаница между встраиванием структур и встраиванием интерфейсов - это разные механизмы.
• Игнорирование того, что встраивание не даёт доступа к приватным полям встроенной структуры.