Come è strutturato il modello orientato agli oggetti…

In Go non esiste un modello orientato agli oggetti tradizionale con una gerarchia profonda di ereditarietà delle classi. Al suo posto, si usano:

Structs: Definiscono campi di dati, simili alle classi senza metodi.
```
type Person struct {
    Name string
    Age  int
}
```
Metodi: Funzioni associate a una struttura specifica. Sono definite separatamente dalla struttura.
```
func (p Person) Greet() string {
    return "Ciao, il mio nome è " + p.Name
}

func (p *Person) CelebrateBirthday() {
    p.Age++
}
```
- I metodi con ricevitore per valore (ad esempio, (p Person)) lavorano con una copia della struttura.
- I metodi con ricevitore per puntatore (ad esempio, (p *Person)) lavorano con l'originale, permettendo di modificare i suoi campi.
Interfacce: Set di firme di metodi. I tipi che implementano tutti i metodi di un'interfaccia soddisfano implicitamente questa interfaccia. Questa è la base del polimorfismo in Go.
```
type Greeter interface {
    Greet() string
}

// Person implementa implicitamente Greeter
```

Composizione (Incrustamento): Invece di ereditarietà, una struttura può incrustare un'altra struttura, accedendo ai suoi campi e metodi.

type Employee struct {
    Person // Incrustamento della struttura Person
    ID     string
}

func (e Employee) GetID() string {
    return e.ID
}

I campi e i metodi incrustati sono disponibili direttamente:

e := Employee{
    Person: Person{Name: "Alice", Age: 30},
    ID:     "E123",
}
fmt.Println(e.Name)     // Accesso al campo Name tramite la Person incrustata
fmt.Println(e.Greet())  // Chiamata al metodo Greet tramite la Person incrustata
fmt.Println(e.GetID())  // Chiamata al metodo Employee

In questo modo, il modello orientato agli oggetti in Go si basa sulla composizione di strutture e sul comportamento definito tramite interfacce, piuttosto che su una gerarchia classica di ereditarietà.

Come è strutturato il modello orientato agli oggetti in Go?