Comment le modèle orienté objet est-il structuré dans…

En Go, il n'existe pas de modèle orienté objet traditionnel avec une hiérarchie profonde d'héritage de classes. À la place, on utilise :

Structures (Structs) : Définissent des champs de données, similaires aux classes sans méthodes.
```
type Person struct {
    Name string
    Age  int
}
```
Méthodes : Fonctions attachées à une structure spécifique. Elles sont définies séparément de la structure.
```
func (p Person) Greet() string {
    return "Bonjour, je m'appelle " + p.Name
}

func (p *Person) CelebrateBirthday() {
    p.Age++
}
```
- Les méthodes avec récepteur par valeur (par exemple, (p Person)) travaillent avec une copie de la structure.
- Les méthodes avec récepteur par pointeur (par exemple, (p *Person)) travaillent avec la structure originale, permettant de modifier ses champs.
Interfaces : Ensemble de signatures de méthodes. Les types qui implémentent toutes les méthodes d'une interface satisfont implicitement cette interface. C'est la base du polymorphisme en Go.
```
type Greeter interface {
    Greet() string
}

// Person implémente implicitement Greeter
```

Composition (Incrustation) : Au lieu de l'héritage, une structure peut incruster une autre structure, accédant à ses champs et méthodes.

type Employee struct {
    Person // Incruste la structure Person
    ID     string
}

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

Les champs et méthodes incrustés sont accessibles directement :

e := Employee{
    Person: Person{Name: "Alice", Age: 30},
    ID:     "E123",
}
fmt.Println(e.Name)     // Accès au champ Name via la Person incrustée
fmt.Println(e.Greet())  // Appel de la méthode Greet via la Person incrustée
fmt.Println(e.GetID())  // Appel de la méthode Employee

Ainsi, le modèle orienté objet en Go repose sur la composition de structures et le comportement défini par des interfaces, plutôt que sur une hiérarchie classique d'héritage de classes.

Comment le modèle orienté objet est-il structuré dans Go?