Pourquoi l'inclusion dans le langage Go n'est-elle pas une héritage?

L'intégration (embedding) en Go permet à une structure d'utiliser les champs et méthodes d'une autre structure comme s'ils lui appartenaient.

Principales différences avec l'héritage :

• Composition vs. Hiérarchie : L'intégration est une forme de composition ("a un"), où une structure possède une autre. L'héritage (en programmation orientée objet classique) est une forme de hiérarchie ("est un"), où une classe est une sous-classe d'une autre.
• Polymorphisme : Go ne supporte pas le polymorphisme de sous-types dans le sens traditionnel de l'héritage. Le polymorphisme en Go est réalisé via des interfaces.
• Accès : L'intégration rend accessibles directement les champs et méthodes visibles de la structure intégrée via la structure externe, mais ne crée pas une hiérarchie de types.
• Absence de surcharge : Il n'existe pas de mécanisme direct de "surcharge" des méthodes de la classe de base. On peut définir une méthode avec le même nom dans la structure externe, qui "masquera" la méthode intégrée.

Exemple d'intégration :

package main

import "fmt"

type Engine struct {
	Cylinders int
}

func (e Engine) Start() {
	fmt.Println("Moteur démarré avec", e.Cylinders, "cylindres")
}

type Car struct {
	Engine // Intégration de Engine
	Brand  string
}

func main() {
	myCar := Car{
		Engine: Engine{Cylinders: 4},
		Brand:  "Toyota",
	}
	myCar.Start() // Accès à la méthode Start de Engine via Car
	fmt.Println("Marque de la voiture :", myCar.Brand)
	fmt.Println("Cylindres du moteur :", myCar.Cylinders) // Accès au champ Cylinders de Engine via Car
}

Dans cet exemple, Car possède un Engine, mais Car n'est pas une sous-classe de Engine. Nous accédons simplement de manière pratique aux champs et méthodes de Engine via la structure Car.