Aller au contenu

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 au this ou self 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()
    // ...
}