Come vengono implementati i concetti di…

In Go, non ci sono i concetti classici di altri linguaggi (Java, C++) come classi, ereditarietà e metodi virtuali. La programmazione orientata agli oggetti si realizza tramite:

Structs: Raggruppano dati (campi).

type Person struct {
	Name string
	Age  int
}

Metodi: Funzioni con un ricevitore associato (struttura o altro tipo). Permettono alle strutture di avere comportamento.
```
func (p Person) Greet() string {
	return "Hello, my name is " + p.Name
}
```
- Ricevitore per valore: Il metodo lavora con una copia della struttura. Le modifiche all'interno del metodo non influenzano la struttura originale.
- Ricevitore per puntatore: Il metodo lavora con la struttura originale tramite un puntatore. Le modifiche all'interno del metodo influenzano la struttura originale.
Interfacce: Definiscono un insieme di firme di metodi a cui un tipo deve conformarsi. Forniscono polimorfismo "per tipizzazione di papera" (duck typing). Un tipo implementa implicitamente un'interfaccia se implementa tutti i suoi metodi.
```
type Greeter interface {
	Greet() string
}

func SayHello(g Greeter) string {
	return g.Greet()
}
```
Incorporamento (Embedding): Permette a una struttura di "incrustare" un'altra struttura o interfaccia. Non è ereditarietà nel senso classico, ma più una composizione. La struttura incorporata diventa un campo anonimo, e i suoi campi e metodi possono essere accessibili direttamente tramite l'istanza della struttura che la incorpora.
```
type Employee struct {
	Person // struttura incorporata
	ID string
}

// Employee ora ha i campi Name e Age, oltre al metodo Greet()

e := Employee{
	Person: Person{Name: "Alice", Age: 30},
	ID:     "E123",
}
fmt.Println(e.Greet()) // chiamata al metodo Greet() di Person tramite Employee
```

Concetto di OOP	Implementazione in Go	Note
Classi	Structs	Non esiste una parola chiave `class` esplicita
Incapsulamento	Campi/metodi esportati (con lettera maiuscola) / non esportati (con lettera minuscola)	Controllo della visibilità a livello di pacchetto
Ereditarietà	Embedding	Composizione invece di ereditarietà gerarchica
Polimorfismo	Interfacce	Duck typing, implementazione implicita delle interfacce

Come vengono implementati i concetti di programmazione orientata agli oggetti (OOP) nel linguaggio Go?