Как в Golang реализовано наследование?

В Go нет традиционного наследования классов, как, например, в Java или C++. Вместо этого используются два механизма:

1. Встраивание (Embedding):

   • Встраивание позволяет внедрять одну структуру или тип в другую.
   • Встроенный тип "передает" свои поля и методы встраивающему типу.
   • Доступ к полям и методам встроенного типа осуществляется напрямую, как если бы они были определены во встраивающем типе.
   • Это имитирует композицию, но с более удобным синтаксисом доступа, похожим на наследование.

   package main
   
   import "fmt"
   
   type Engine struct {
       Type string
   }
   
   func (e Engine) Start() {
       fmt.Println(e.Type, "engine started")
   }
   
   type Car struct {
       Engine // Встраивание структуры Engine
       Model  string
   }
   
   func main() {
       car := Car{
           Engine: Engine{Type: "V8"},
           Model:  "Mustang",
       }
   
       // Доступ к полю и методу встроенной структуры напрямую
       fmt.Println("Car model:", car.Model)
       car.Start() // Вызов метода встроенной структуры
   }
   

2. Интерфейсы:

   • Интерфейсы определяют набор методов, которые должен реализовать тип.
   • Они определяют "поведение", а не структуру данных.
   • Тип не должен явно объявлять, что он реализует интерфейс; достаточно реализовать все методы, определенные в интерфейсе.
   • Интерфейсы обеспечивают полиморфизм.

   package main
   
   import "fmt"
   
   type Speaker interface {
       Speak()
   }
   
   type Dog struct {
       Name string
   }
   
   func (d Dog) Speak() {
       fmt.Println(d.Name, "says Woof!")
   }
   
   type Cat struct {
       Name string
   }
   
   func (c Cat) Speak() {
       fmt.Println(c.Name, "says Meow!")
   }
   
   func main() {
       animals := []Speaker{
           Dog{Name: "Buddy"},
           Cat{Name: "Whiskers"},
       }
   
       for _, animal := range animals {
           animal.Speak() // Полиморфный вызов метода Speak
       }
   }
   

Сочетание встраивания и интерфейсов позволяет Go достигать гибкости и повторного использования кода без сложностей и проблем, связанных с традиционным наследованием (например, проблема "алмаза"). В Go предпочтение отдается композиции и интерфейсам над иерархиями наследования.