Hoe wordt erfelijkheid geïmplementeerd in Golang…

In Go bestaat er geen traditionele klasse-erfenis zoals in Java of C++. In plaats daarvan worden twee mechanismen gebruikt:

Embedding (Inbedden):

Embedding stelt je in staat om een structuur of type in een andere te integreren.
Het ingebedde type "geeft" zijn velden en methoden door aan het type dat het embed.
Toegang tot de velden en methoden van het ingebedde type gebeurt direct, alsof ze in het embed-type zijn gedefinieerd.
Dit imiteert compositie, maar met een handigere toegangssyntaxis, vergelijkbaar met erfenis.

package main

import "fmt"

type Engine struct {
    Type string
}

func (e Engine) Start() {
    fmt.Println(e.Type, "motor gestart")
}

type Car struct {
    Engine // Embedding van de Engine-structuur
    Model  string
}

func main() {
    car := Car{
        Engine: Engine{Type: "V8"},
        Model:  "Mustang",
    }

    // Directe toegang tot velden en methoden van de embedded structuur
    fmt.Println("Model van de auto:", car.Model)
    car.Start() // Aanroepen van de methode van de embedded structuur
}

Interfaces:

Interfaces definiëren een set methoden die een type moet implementeren.
Ze definiëren "gedrag", niet data-structuur.
Het type hoeft niet expliciet te verklaren dat het een interface implementeert; het volstaat om alle methoden te implementeren die in de interface zijn gedefinieerd.
Interfaces bieden polymorfisme.

package main

import "fmt"

type Speaker interface {
    Speak()
}

type Dog struct {
    Name string
}

func (d Dog) Speak() {
    fmt.Println(d.Name, "zegt Woof!")
}

type Cat struct {
    Name string
}

func (c Cat) Speak() {
    fmt.Println(c.Name, "zegt Miau!")
}

func main() {
    animals := []Speaker{
        Dog{Name: "Buddy"},
        Cat{Name: "Whiskers"},
    }

    for _, animal := range animals {
        animal.Speak() // Polymorfe aanroep van de Speak-methode
    }
}

De combinatie van embedding en interfaces stelt Go in staat om flexibiliteit en hergebruik van code te bereiken zonder de complexiteit en problemen die gepaard gaan met traditioneel erfelijkheid (bijvoorbeeld het "diamant"-probleem). In Go worden compositie en interfaces geprefereerd boven erfhierarchieën.

Hoe wordt erfelijkheid geïmplementeerd in Golang?