Structures et méthodes#
Définition des structures#
- Une structure est un type composite en Go qui permet de regrouper des valeurs de différents types.
- Les structures sont définies en utilisant le mot-clé
struct
. - Syntaxe pour définir une structure :
type NomStructure struct { champ1 type1 champ2 type2 // ... }
- Les noms des champs commencent par une majuscule s'ils doivent être visibles en dehors du package. Sinon, ils commencent par une minuscule.
Création et initialisation des instances de structures#
- Les instances de structures peuvent être créées en utilisant le nom de la structure comme un type.
- Syntaxe pour l'initialisation d'une structure :
var s NomStructure // s est maintenant une instance de NomStructure avec des valeurs zéro
- Initialisation avec des valeurs spécifiques :
s := NomStructure{valeur1, valeur2}
- Les champs spécifiques peuvent être initialisés en utilisant le nom du champ :
s := NomStructure{champ1: valeur1, champ2: valeur2}
Méthodes associées aux structures#
- Les méthodes sont des fonctions associées à des types spécifiques (structures).
- Syntaxe pour définir une méthode :
func (r NomStructure) NomMethode(param1 type1, param2 type2) returnType { // ... }
r
est appelé récepteur de la méthode. Il est similaire authis
ouself
dans d'autres langages de programmation.
Méthodes avec récepteurs de pointeurs#
- Les méthodes peuvent avoir des récepteurs de pointeurs, ce qui signifie qu'elles peuvent modifier l'instance de la structure.
- Syntaxe pour une méthode avec un récepteur de pointeur :
func (r *NomStructure) NomMethode(param1 type1, param2 type2) returnType { // ... }
- Si une méthode a un récepteur de pointeur, l'instance de la structure est accessible et modifiable directement, pas seulement sa copie.
Composition et héritage#
- Go n'a pas d'héritage classique, mais utilise la composition à la place.
- Une structure peut "hériter" d'une autre en l'incorporant comme un champ anonyme.
- Syntaxe pour la composition :
type NomStructure2 struct { NomStructure // hérite de tous les champs et méthodes de NomStructure // ... }
Interfaces et polymorphisme#
- Une interface est définie par un ensemble de méthodes. Tout type qui implémente ces méthodes satisfait l'interface.
- Syntaxe pour définir une interface :
type NomInterface interface { NomMethode1(param1 type1, param2 type2) returnType NomMethode2(param1 type1, param2 type2) returnType // ... }
- Les structures qui implémentent toutes les méthodes d'une interface sont automatiquement considérées comme satisfaisant l'interface.
- Les interfaces permettent un polymorphisme de type en Go, où une fonction peut accepter un paramètre d'interface et se comporter différemment selon le type réel passé. *
Exemple de polymorphisme :
func faireQuelqueChose(i NomInterface) {
i.NomMethode1()
// ...
}