Jak w Golang zaimplementowano dziedziczenie?

W Go nie ma tradycyjnego dziedziczenia klas, jak w Java czy C++. Zamiast tego używa się dwóch mechanizmów:

1. Wbudowywanie (Embedding):

   • Wbudowywanie pozwala na włączenie jednej struktury lub typu do innej.
   • Wbudowany typ "przekazuje" swoje pola i metody do typu, który go wbudowuje.
   • Dostęp do pól i metod wbudowanego typu odbywa się bezpośrednio, jakby były zdefiniowane w typie wbudowującym.
   • To imituje kompozycję, ale z wygodniejszą składnią dostępu, podobną do dziedziczenia.

   package main
   
   import "fmt"
   
   type Engine struct {
       Type string
   }
   
   func (e Engine) Start() {
       fmt.Println(e.Type, "silnik uruchomiony")
   }
   
   type Car struct {
       Engine // Wbudowanie struktury Engine
       Model  string
   }
   
   func main() {
       car := Car{
           Engine: Engine{Type: "V8"},
           Model:  "Mustang",
       }
   
       // Bezpośredni dostęp do pól i metod wbudowanej struktury
       fmt.Println("Model samochodu:", car.Model)
       car.Start() // Wywołanie metody wbudowanej struktury
   }
   

2. Interfejsy:

   • Interfejsy określają zestaw metod, które musi zaimplementować typ.
   • Określają "zachowanie", a nie strukturę danych.
   • Typ nie musi jawnie deklarować, że implementuje interfejs; wystarczy zaimplementować wszystkie metody zdefiniowane w interfejsie.
   • Interfejsy zapewniają polimorfizm.

   package main
   
   import "fmt"
   
   type Speaker interface {
       Speak()
   }
   
   type Dog struct {
       Name string
   }
   
   func (d Dog) Speak() {
       fmt.Println(d.Name, "mówi Woof!")
   }
   
   type Cat struct {
       Name string
   }
   
   func (c Cat) Speak() {
       fmt.Println(c.Name, "mówi Miau!")
   }
   
   func main() {
       animals := []Speaker{
           Dog{Name: "Buddy"},
           Cat{Name: "Whiskers"},
       }
   
       for _, animal := range animals {
           animal.Speak() // Polimorficzne wywołanie metody Speak
       }
   }
   

Połączenie wbudowywania i interfejsów pozwala Go osiągnąć elastyczność i ponowne użycie kodu bez złożoności i problemów związanych z tradycyjnym dziedziczeniem (np. problem "diamentu"). W Go preferuje się kompozycję i interfejsy zamiast hierarchii dziedziczenia.