De ce încorporarea în limbajul Go nu este moștenire?

Includerea (embedding) în Go permite unei structuri să utilizeze câmpurile și metodele altei structuri ca și cum ar fi ale sale.

Diferențele cheie față de moștenire:

• Compoziție vs. Ierarhie: Includerea este o formă de compoziție ("are o"), unde o structură are o altă. Moștenirea (în paradigma OOP clasică) este o formă de ierarhie ("este un"), unde o clasă este o subclasă a alteia.
• Polimorfism: Go nu suportă polimorfismul de subtip în sensul tradițional al moștenirii. Polimorfismul în Go se realizează prin interfețe.
• Acces: Includerea face ca câmpurile și metodele vizibile ale structurii incluse să fie accesibile direct prin structura externă, dar nu creează o ierarhie de tipuri.
• Lipsa de override: Nu există un mecanism direct de "suprascriere" a metodelor clasei de bază. Se poate defini o metodă cu același nume în structura externă, care "ascunde" metoda inclusă.

Exemplu de includere:

package main

import "fmt"

type Engine struct {
	Cylinders int
}

func (e Engine) Start() {
	fmt.Println("Motor pornit cu", e.Cylinders, "cilindri")
}

type Car struct {
	Engine // Includerea Engine
	Brand  string
}

func main() {
	myCar := Car{
		Engine: Engine{Cylinders: 4},
		Brand:  "Toyota",
	}
	myCar.Start() // Acces la metoda Start a Engine prin Car
	fmt.Println("Marca mașinii:", myCar.Brand)
	fmt.Println("Cilindri ai motorului:", myCar.Cylinders) // Acces la câmpul Cylinders al Engine prin Car
}

În acest exemplu, Car are un Engine, dar Car nu este o subclasă a Engine. Pur și simplu accesăm convenabil câmpurile și metodele Engine prin structura Car.