Comment les concepts de programmation orientée objet…

En Go, il n'existe pas les concepts classiques de classes, d'héritage et de méthodes virtuelles que l'on trouve dans d'autres langages (Java, C++). La programmation orientée objet est réalisée via :

Structures (Structs) : Regroupent des données (champs).

type Person struct {
	Name string
	Age  int
}

Méthodes : Fonctions avec un récepteur associé (structure ou autre type). Permettent aux structures d'avoir un comportement.
```
func (p Person) Greet() string {
	return "Hello, my name is " + p.Name
}
```
- Récepteur par valeur : La méthode travaille avec une copie de la structure. Les changements dans la méthode n'affectent pas la structure originale.
- Récepteur par pointeur : La méthode travaille avec la structure originale via un pointeur. Les changements dans la méthode affectent la structure originale.
Interfaces : Définissent un ensemble de signatures de méthodes auxquelles un type doit se conformer. Fournissent du polymorphisme "par typage de canard" (duck typing). Un type implémente implicitement une interface s'il implémente toutes ses méthodes.
```
type Greeter interface {
	Greet() string
}

func SayHello(g Greeter) string {
	return g.Greet()
}
```
Incrustation (Embedding) : Permet à une structure d'"incruster" une autre structure ou interface. Ce n'est pas une héritage au sens classique, mais plutôt une composition. La structure incrustée devient un champ anonyme, et ses champs et méthodes peuvent être accédés directement via l'instance de la structure qui l'inclut.
```
type Employee struct {
	Person // structure incrustée
	ID string
}

// Employee possède maintenant les champs Name et Age, ainsi que la méthode Greet()

e := Employee{
	Person: Person{Name: "Alice", Age: 30},
	ID:     "E123",
}
fmt.Println(e.Greet()) // appel à la méthode Greet() de Person via Employee
```

Concept POO	Mise en œuvre en Go	Remarques
Classes	Structures	Pas de mot-clé explicite `class`
Encapsulation	Champs/méthodes exportables (avec majuscule) / non exportables (avec minuscule)	Contrôle de la visibilité au niveau du package
Héritage	Incrustation (Embedding)	Composition plutôt qu'héritage hiérarchique
Polymorphisme	Interfaces	Typage de canard, implémentation implicite des interfaces

Comment les concepts de programmation orientée objet (POO) sont-ils implémentés dans le langage Go?