Leçons de niveau 14

Ruby/Méthodes (fin)

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
Début de la boite de navigation du chapitre
Méthodes (fin)
Icône de la faculté
Chapitre no 14
Leçon : Ruby
Chap. préc. :Symboles
fin de la boite de navigation du chapitre
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « Ruby : Méthodes (fin)
Ruby/Méthodes (fin)
 », n'a pu être restituée correctement ci-dessus.

Les alias de méthodes[modifier | modifier le wikicode]


L'intérêt est de disposer de plusieurs noms pour une seule méthode, ou encore de conserver l'ancienne méthode (afin de pouvoir éventuellement la rappeler) avant de la redéfinir.

Cette opération se fait le plus simplement du monde à l'aide du mot-clé alias suivi du nom de la méthode à créer et du nom de la méthode originelle, comme l'illustre cet exemple :

Début de l'exemple
Fin de l'exemple


Nous venons de créer un alias denomme pour la méthode nomme. Au lieu de passer les noms des méthodes en question, nous pouvons tout aussi bien passer les symboles s'y rapportant :

Début de l'exemple
Fin de l'exemple


Le résultat est le même si vous aviez défini une méthode denomme identique à la méthode nomme.


Méthodes privées et protégées[modifier | modifier le wikicode]


En plaçant le mot-clé public au sein de la classe, toutes les méthodes déclarées après seront publiques. Ce mot est optionnel, et toutes les méthodes déclarées au début de la classe seront publiques jusqu'à ce qu'on place un autre mot-clé pour modifier l'accès :

Début de l'exemple
Fin de l'exemple


Nous voyons ici que run est accessible depuis l'extérieur de la classe. Pour éviter cela, nous pouvons réglementer l'accès à certaines méthodes en les rendant privées ou protégées.

Les méthodes privées[modifier | modifier le wikicode]

Le mot-clé à placer pour déclarer des méthodes privées est private :

Début de l'exemple
Fin de l'exemple


Toutes les méthodes déclarées après le mot-clé private sont privées, jusqu'à (éventuellement) un autre changement d'accès.


Ainsi, en considérant la classe définie plus haut :

Début de l'exemple
Fin de l'exemple


En appelant la méthode privée run_private depuis l'extérieur de la classe, on obtient une erreur. En revanche, cette méthode peut être appelée depuis une méthode publique (run par exemple).

Les méthodes protégées[modifier | modifier le wikicode]

Le fonctionnement des méthodes protégées est (quasiment) le même que celui des méthodes privées. Le mot-clé changeant l'accès de ces méthodes est protected :

Début de l'exemple
Fin de l'exemple


Les méthodes protégées sont accessibles depuis la classe et ses sous-classes, mais pas depuis l'extérieur. Ainsi, l'appel de run_protect depuis l'extérieur de la classe provoque une erreur, mais l'appel à run (elle-même appelant run_protect) est correct.


Considérons cette classe :

Début de l'exemple
Fin de l'exemple


Autres précisions[modifier | modifier le wikicode]

Si vous voulez que des méthodes déclarées après d'autres méthodes privées ou protégées soient publiques, vous devez (re)placer le mot-clé public avant leur déclaration.


Les accesseurs[modifier | modifier le wikicode]


Vous pouvez bien entendu les écrire vous-mêmes, par exemple pour une classe Ordinateur ayant une variable d'instance @prix :

Début de l'exemple
Fin de l'exemple


Il nous suffit d'appeler la méthode prix= sur l’objet monOrdi afin de modifier la variable @prix, et un appel à prix retourne la valeur de cette variable d'instance :

Début de l'exemple
Fin de l'exemple


La première méthode est une méthode d'écriture (ou setter) puisqu'on modifie la variable, tandis que la seconde est une méthode de lecture (ou getter) puisqu'on ne s'intéresse qu’à la valeur actuelle de la variable en question.

Il peut être long (et fastidieux) de définir ces méthodes pour chacune de nos variables d'instance, aussi Ruby peut s'en charger à notre place.

attr_reader[modifier | modifier le wikicode]

Début de l'exemple
Fin de l'exemple


Nous passons le symbole :prix à la méthode attr_reader (Module#attr_reader). Cela a pour effet de créer la méthode de lecture pour cette variable. Nous pouvons donc utiliser monOrdi.prix comme si nous l'avions défini nous-mêmes.

Pour définir plusieurs de ces méthodes en une seule fois, il suffit de passer tous les symboles (correspondants aux variables d'instance) à la méthode attr_reader :

Début de l'exemple
Fin de l'exemple


attr_writer[modifier | modifier le wikicode]

Pour disposer de la méthode d'écriture, le principe est le même : Ruby met à notre disposition une méthode attr_writer à laquelle nous passons les symboles correspondant aux variables d'instance :

Début de l'exemple
Fin de l'exemple


Ceci nous permet d’utiliser monOrdi.prix= comme si nous l'avions défini nous-mêmes.

attr_accessor[modifier | modifier le wikicode]

Une dernière méthode, attr_accessor (Module#attr_accessor), fonctionnant de la même manière que les deux précédentes, permet de déclarer en une seule fois les méthodes de lecture et d'écriture pour chaque variable passée en paramètre.

Début de l'exemple
Fin de l'exemple


Paramètres optionnels[modifier | modifier le wikicode]

Lors de la déclaration d'une méthode, vous pouvez préciser si certains paramètres sont optionnels ; il est alors possible de leur assigner une valeur par défaut . Mais il est également possible d'envoyer des paramètres supplémentaires à une méthode, ils seront alors rangés dans un tableau. Voyons comment procéder :

Début de l'exemple
Fin de l'exemple


À travers cet exemple, nous voyons que le paramètre intonation est obligatoire, que le paramètre langue ne l'est pas : si aucune valeur n'est précisée, sa valeur par défaut sera "fr". La méthode rangera tous les arguments supplémentaires qu'elle recevra dans un tableau nommé duree.

Ainsi, voici quelques possibilités pour appeler cette méthode :

Début de l'exemple
Fin de l'exemple


Dans le dernier exemple, le tableau duree sera tel que : duree = [5, 6, 9, 27].

Pour que notre méthode puisse recevoir un nombre quelconque de paramètres, il nous suffit de la déclarer ainsi :

Début de l'exemple
Fin de l'exemple


Tous les arguments seront placés dans le tableau params.

Conclusion[modifier | modifier le wikicode]

Ce que nous venons de voir dans ce chapitre permet d’utiliser l'encapsulation (définie dans un chapitre précédent) : nous définissons des accesseurs (en lecture) publics pour les variables de nos instances et nous masquons le reste (en écriture) à l'utilisateur de la classe.