# Ruby/Méthodes (fin)
## Les alias de méthodes

Créer un alias d'une méthode vous permet de créer une copie conforme de cette méthode : vous obtenez une nouvelle méthode fonctionnant de manière strictement identique à la première, disponible sous un nouveau nom.
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 :
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 :
Le résultat est le même si vous aviez défini une méthode denomme identique à la méthode nomme.
alias doit être suivi de deux méthodes, ni plus, ni moins (la copie en premier, l'originale en second).
Redéfinir une de ces deux méthodes n'altérera pas l'autre.

## Méthodes privées et protégées

Tout d’abord, par défaut, les méthodes sont dites publiques, c'est-à-dire qu’elles sont accessibles à l'intérieur comme à l'extérieur de la classe, de même que par les sous-classes de la classe en question. Elles sont donc utilisables partout.
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 :
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

Le mot-clé à placer pour déclarer des méthodes privées est private :
Toutes les méthodes déclarées après le mot-clé private sont privées, jusqu'à (éventuellement) un autre changement d'accès.
Les méthodes privées ne sont accessibles qu’à l'intérieur de la classe elle-même et de ses sous-classes, pas à l'extérieur !
Ainsi, en considérant la classe définie plus haut :
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

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 :
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.
Un objet peut accéder aux méthodes protégées d'un autre objet du même type, mais pas aux méthodes privées.
Considérons cette classe :

### Autres précisions

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.
Vous pouvez placer autant de méthodes que vous le souhaitez après chacun de ces mots-clés, vous ne devez pas le remettre avant chaque méthode comme dans d'autres langages.

## Les accesseurs

Les accesseurs sont des méthodes particulières qui vous permettent d'accéder aux variables d'instance de votre objet pour les lire ou les modifier.
Vous pouvez bien entendu les écrire vous-mêmes, par exemple pour une classe Ordinateur ayant une variable d'instance @prix :
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 :
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

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 :

### attr_writer

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 :
Ceci nous permet d’utiliser monOrdi.prix= comme si nous l'avions défini nous-mêmes.

### attr_accessor

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.

## Paramètres optionnels

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 :
À 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 :
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 :
Tous les arguments seront placés dans le tableau params.

## Conclusion

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.
* Symboles