Comment l'héritage est-il implémenté en Golang…

En Go, il n’y a pas d’héritage de classes traditionnel, comme en Java ou C++. À la place, deux mécanismes sont utilisés:

Embedding (Incrustation):

L’incrustation permet d’intégrer une structure ou un type dans une autre.
Le type incrusté "transmet" ses champs et méthodes au type qui l’incruste.
L’accès aux champs et méthodes du type incrusté se fait directement, comme s’ils étaient définis dans le type qui l’incruste.
Cela imite la composition, mais avec une syntaxe d’accès plus pratique, semblable à l’héritage.

package main

import "fmt"

type Engine struct {
    Type string
}

func (e Engine) Start() {
    fmt.Println(e.Type, "moteur démarré")
}

type Car struct {
    Engine // Incrustation de la structure Engine
    Model  string
}

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

    // Accès direct aux champs et méthodes de la structure incrustée
    fmt.Println("Modèle de la voiture:", car.Model)
    car.Start() // Appel de la méthode de la structure incrustée
}

Interfaces:

Les interfaces définissent un ensemble de méthodes qu’un type doit implémenter.
Elles définissent le "comportement", pas la structure de données.
Le type n’a pas besoin de déclarer explicitement qu’il implémente l’interface; il suffit d’implémenter toutes les méthodes définies.
Les interfaces offrent du polymorphisme.

package main

import "fmt"

type Speaker interface {
    Speak()
}

type Dog struct {
    Name string
}

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

type Cat struct {
    Name string
}

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

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

    for _, animal := range animals {
        animal.Speak() // Appel polymorphe de la méthode Speak
    }
}

La combinaison de l’incrustation et des interfaces permet à Go d’atteindre flexibilité et réutilisation du code sans les complexités et problèmes liés à l’héritage traditionnel (par exemple, le problème du "diamant"). En Go, la composition et les interfaces sont préférées aux hiérarchies d’héritage.

Comment l'héritage est-il implémenté en Golang?