Perché l'inclusione nel linguaggio Go non è ereditarietà?

L'incorporamento (embedding) in Go consente a una struttura di utilizzare i campi e i metodi di un'altra struttura come se fossero propri.

Differenze chiave rispetto all'ereditarietà:

• Composizione vs. Gerarchia: L'incorporamento è una forma di composizione ("ha un"), dove una struttura possiede un'altra. L'ereditarietà (nel paradigma OOP classico) è una forma di gerarchia ("è un"), dove una classe è una sottoclasse di un'altra.
• Polimorfismo: Go non supporta il polimorfismo di sottotipo nel senso tradizionale di ereditarietà. Il polimorfismo in Go si realizza tramite interfacce.
• Accesso: L'incorporamento rende accessibili direttamente i campi e i metodi visibili della struttura incorporata tramite la struttura esterna, ma non crea una gerarchia di tipi.
• Mancanza di override: Non esiste un meccanismo diretto di "override" dei metodi della classe base. È possibile definire un metodo con lo stesso nome nella struttura esterna, che "oscura" il metodo incorporato.

Esempio di incorporamento:

package main

import "fmt"

type Engine struct {
	Cylinders int
}

func (e Engine) Start() {
	fmt.Println("Motore avviato con", e.Cylinders, "cilindri")
}

type Car struct {
	Engine // Incorporamento di Engine
	Brand  string
}

func main() {
	myCar := Car{
		Engine: Engine{Cylinders: 4},
		Brand:  "Toyota",
	}
	myCar.Start() // Accesso al metodo Start di Engine tramite Car
	fmt.Println("Marca dell'auto:", myCar.Brand)
	fmt.Println("Cilindri del motore:", myCar.Cylinders) // Accesso al campo Cylinders di Engine tramite Car
}

In questo esempio, Car possiede un Engine, ma Car non è una sottoclasse di Engine. Accediamo semplicemente in modo conveniente ai campi e ai metodi di Engine tramite la struttura Car.