¿Por qué la incrustación en el lenguaje Go no es herencia?

La incorporación (embedding) en Go permite que una estructura utilice los campos y métodos de otra estructura como si fueran propios.

Diferencias clave con la herencia:

• Composición vs. Jerarquía: La incorporación es una forma de composición ("tiene un"), donde una estructura tiene otra. La herencia (en la programación orientada a objetos clásica) es una forma de jerarquía ("es un"), donde una clase es una subclase de otra.
• Polimorfismo: Go no soporta el polimorfismo de subtipos en el sentido tradicional de herencia. El polimorfismo en Go se implementa a través de interfaces.
• Acceso: La incorporación hace que los campos y métodos visibles de la estructura incorporada sean accesibles directamente a través de la estructura externa, pero no crea una jerarquía de tipos.
• Ausencia de sobrescritura: No existe un mecanismo directo de "sobrescritura" de métodos de la clase base. Se puede definir un método con el mismo nombre en la estructura externa, que "ocultará" el método incorporado.

Ejemplo de incorporación:

package main

import "fmt"

type Engine struct {
	Cylinders int
}

func (e Engine) Start() {
	fmt.Println("Motor iniciado con", e.Cylinders, "cilindros")
}

type Car struct {
	Engine // Incorporación de Engine
	Brand  string
}

func main() {
	myCar := Car{
		Engine: Engine{Cylinders: 4},
		Brand:  "Toyota",
	}
	myCar.Start() // Acceso al método Start del Engine a través de Car
	fmt.Println("Marca del coche:", myCar.Brand)
	fmt.Println("Cilindros del motor:", myCar.Cylinders) // Acceso al campo Cylinders del Engine a través de Car
}

En este ejemplo, Car tiene un Engine, pero Car no es un subtipo de Engine. Simplemente accedemos de manera conveniente a los campos y métodos de Engine a través de la estructura Car.