Jak je v Golangu implementováno dědění?

V Go neexistuje tradiční dědičnost tříd, jako například v Javě nebo C++. Místo toho se používají dva mechanismy:

1. Vkládání (Embedding):

   • Vkládání umožňuje začlenit jednu strukturu nebo typ do jiné.
   • Vkládaný typ "předává" svá pole a metody vkládajícímu typu.
   • Přístup k polím a metodám vkládaného typu je přímo, jako by byly definovány ve vkládajícím typu.
   • To napodobuje kompozici, ale s pohodlnější syntaxí přístupu, podobně jako dědičnost.

   package main
   
   import "fmt"
   
   type Engine struct {
       Type string
   }
   
   func (e Engine) Start() {
       fmt.Println(e.Type, "motor spuštěn")
   }
   
   type Car struct {
       Engine // Vkládání struktury Engine
       Model  string
   }
   
   func main() {
       car := Car{
           Engine: Engine{Type: "V8"},
           Model:  "Mustang",
       }
   
       // Přímý přístup k polím a metodám vkládané struktury
       fmt.Println("Model auta:", car.Model)
       car.Start() // Volání metody vkládané struktury
   }
   

2. Rozhraní (Interfaces):

   • Rozhraní definují sadu metod, které musí typ implementovat.
   • Určují "chování", nikoliv datovou strukturu.
   • Typ nemusí explicitně deklarovat, že implementuje rozhraní; stačí implementovat všechny metody definované v rozhraní.
   • Rozhraní poskytují polymorfismus.

   package main
   
   import "fmt"
   
   type Speaker interface {
       Speak()
   }
   
   type Dog struct {
       Name string
   }
   
   func (d Dog) Speak() {
       fmt.Println(d.Name, "říká Woof!")
   }
   
   type Cat struct {
       Name string
   }
   
   func (c Cat) Speak() {
       fmt.Println(c.Name, "říká Miau!")
   }
   
   func main() {
       animals := []Speaker{
           Dog{Name: "Buddy"},
           Cat{Name: "Whiskers"},
       }
   
       for _, animal := range animals {
           animal.Speak() // Polymorfní volání metody Speak
       }
   }
   

Kombinace vkládání a rozhraní umožňuje Go dosáhnout flexibility a opětovného použití kódu bez složitostí a problémů spojených s tradiční dědičností (například problém "diamantu"). V Go se upřednostňuje kompozice a rozhraní před hierarchiemi dědičnosti.