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

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

1. Вграждане (Embedding):

   • Вграждането позволява да се включи една структура или тип в друга.
   • Вграденият тип "предава" своите полета и методи на вграждащия тип.
   • Достъпът до полетата и методите на вградения тип става директно, сякаш са дефинирани в вграждащия тип.
   • Това имитира композиция, но с по-удобен синтаксис за достъп, подобен на наследяването.

   package main
   
   import "fmt"
   
   type Engine struct {
       Type string
   }
   
   func (e Engine) Start() {
       fmt.Println(e.Type, "двигател стартира")
   }
   
   type Car struct {
       Engine // Вграждане на структурата Engine
       Model  string
   }
   
   func main() {
       car := Car{
           Engine: Engine{Type: "V8"},
           Model:  "Mustang",
       }
   
       // Достъп до полетата и методите на вградения тип директно
       fmt.Println("Модел на колата:", 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, "казва Woof!")
   }
   
   type Cat struct {
       Name string
   }
   
   func (c Cat) Speak() {
       fmt.Println(c.Name, "казва Miau!")
   }
   
   func main() {
       animals := []Speaker{
           Dog{Name: "Buddy"},
           Cat{Name: "Whiskers"},
       }
   
       for _, animal := range animals {
           animal.Speak() // Полиморфно извикване на метода Speak
       }
   }
   

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