Cum se implementează moștenirea în Golang?

În Go, nu există moștenire tradițională a claselor, ca în Java sau C++. În schimb, se folosesc două mecanisme:

1. Incorporare (Embedding):

   • Încorporarea permite integrarea unei structuri sau tip într-una alta.
   • Tipul încorporat "transmite" câmpurile și metodele sale tipului care îl încorporează.
   • Accesul la câmpurile și metodele tipului încorporat se face direct, ca și cum ar fi definite în tipul care îl încorporează.
   • Acest lucru imită compoziția, dar cu o sintaxă de acces mai convenabilă, similară cu moștenirea.

   package main
   
   import "fmt"
   
   type Engine struct {
       Type string
   }
   
   func (e Engine) Start() {
       fmt.Println(e.Type, "motor pornit")
   }
   
   type Car struct {
       Engine // Încorporarea structurii Engine
       Model  string
   }
   
   func main() {
       car := Car{
           Engine: Engine{Type: "V8"},
           Model:  "Mustang",
       }
   
       // Acces direct la câmpurile și metodele structurii încorporate
       fmt.Println("Modelul mașinii:", car.Model)
       car.Start() // Apelarea metodei structurii încorporate
   }
   

2. Interfețe:

   • Interfețele definesc un set de metode pe care un tip trebuie să le implementeze.
   • Ele definesc "comportamentul", nu structura datelor.
   • Tipul nu trebuie să declare explicit că implementează interfața; este suficient să implementeze toate metodele definite în ea.
   • Interfețele asigură polimorfism.

   package main
   
   import "fmt"
   
   type Speaker interface {
       Speak()
   }
   
   type Dog struct {
       Name string
   }
   
   func (d Dog) Speak() {
       fmt.Println(d.Name, "zice Woof!")
   }
   
   type Cat struct {
       Name string
   }
   
   func (c Cat) Speak() {
       fmt.Println(c.Name, "zice Miau!")
   }
   
   func main() {
       animals := []Speaker{
           Dog{Name: "Buddy"},
           Cat{Name: "Whiskers"},
       }
   
       for _, animal := range animals {
           animal.Speak() // Apel polimorfic al metodei Speak
       }
   }
   

Combinația dintre încorporare și interfețe permite Go să atingă flexibilitate și reutilizare a codului fără complexitățile și problemele asociate cu moștenirea tradițională (de exemplu, problema "diamantului"). În Go, se preferă compoziția și interfețele în locul ierarhiilor de moștenire.