Voila voila, on y est. La Programmation Orientée Objet, la POO. Le meilleur outils de programmation qui puisse être actuellement.
Je préviens de suite, que le concept POO est loin d'être évident à saisir, cependant une fois que vous l'aurez compris, vous vous rendrez compte de son incroyable utilité. Je vous conseil donc de prendre du temps à bien relire chaque chose jusqu'à le comprendre. Et surtout à la moindre question n'hésitez pas à les poser.
On va donc commencer par la 'classe', qui est tout bêtement l'abstraction d'un objet. Oula, vous êtes déjà perdu!! vite un exemple simplifié.
Prenons ma voiture. C'est un objet concret qui a des propriétés qui la rendent unique (immatriculation, marque sur la carrosserie, etc..) et je peux interragir avec (ouvrir une porte, tourner le volant, demarrer, etc...). Cependant MA voiture, est avant tout UNE voiture. Attention, ce n'est pas du tout la même chose, MA voiture est un objet concret, UNE voiture est abstrait, c'est ce que l'on appelera une 'classe'.
Précisons la chose en prenant un constructeur automobile quelconque, Renaud par exemple. Prétez bien attention au terme 'constructeur', je n'ai pas choisis l'exemple de la voiture au hazard. Ce constructeur fabrique des nouvelles voitures, c'est à dire construire un objet concret à partir de plans définissant une voiture.
Essayons de définir quelles sont les propriétés d'une voiture, et ce que l'on peut faire avec :
| Code |
| Voiture ____________________ Propriétés : - Nombre de roues - Couleur - Poids - Cylindré - Vitesse Max - Nombre de vitesse - Longueur - Largeur - Hauteur - Volume du réservoir - Nombre de portes - immatriculation Fonctionnalités : - Ouvrir une porte - Démarrer - Accelerer - changer de vitesse - Freiner - Eteindre - Remplir le réservoir - Tourner le volant |
Cela reste une vision rapide de ce que peut être UNE voiture, elle posséde des propriétés ou 'attributs', ainsi que des fonctionnalités ou 'méthodes' qui lui sont propre. Cependant tant qu'elle n'est pas construite, je ne peux pas intéragir avec.
Si je veux une nouvelle voiture, je vais donc donner des paramètres au constructeur pour qu'il me fournisse une voiture personnalisée, qui deviendra MA voiture : couleur = noir, nombre de portes = 5, le reste des paramètres sont définit par le constructeur par défaut selon le modèle que je choisi.
A la sortie de l'usine le constructeur aura créé MA voiture selon les plans qu'il posséde et les paramètres que je lui ais transmis. En langage objet, on appel cette action, une instanciation de classe. Une instance de classe est appelé un objet. Je rappel que les termes sont importants, prenez le temps de bien tout relire, pour bien comprendre les bases.
Donc dans une classe, les attributs seront des variables de classe qui ne seront accessible que dans l'objet de classe, elles sont donc privées par défaut. Et les méthodes seront des fonctions de classe qui seront appelable via l'objet de classe créé, elles sont donc publiques. Ca peut paraitre compliqué, mais avec quelques exemples, ça le sera un peu moins.
on va donc créer une classe rectangle :
| Code |
| classe rectangle ____________________ Attributs : - largeur - longueur Méthode : - changer_largeur - changer_longueur - calculer_perimetre - calculer_surface |
Je pense que l'on a fait le tour de ce que peut faire d'un rectangle. Voila comment cette classe est déclaré en Ruby :
| (Ruby) | |
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
class Rectangle
def initialize @largeur = 0 @longueur = 0 end def changer_largeur(param_largeur = 0) @largeur = param_largeur end def changer_longueur(param_longueur = 0) @longueur = param_longueur end def calculer_perimetre return ( @largeur * 2 ) + ( @longueur * 2 ) end def calculer_surface return @largeur * @longueur end end |
Récapitulons les instructions importantes :
class : permet de déclarer une nouvelle classe
def : permet de déclarer des fonctions ou procédures de classe, donc des méthodes
Attention, le nom de la classe doit obligatoirement commencer par une majuscule. Attention, une variable de classe doit avoir comme préfixe le caractère '@' pour qu'elle puisse être accessible dans l'intégralité de la classe.
Attention, la méthode initialize est le constructeur. Cette méthode est appelé automatiquement lors de la crèation d'un objet de classe.
Pour plus de clarté, voici un exemple d'utilisation de cette classe :
| (Ruby) | |
| 1 2 3 4 5 |
un_rectangle = Rectangle.new
un_rectangle.changer_largeur(6) un_rectangle.changer_longueur(9) print un_rectangle.calculer_perimetre print un_rectangle.calculer_surface |
La syntaxe pour créer un objet de classe :
[nom de l'objet] = [nom de la classe].new
L'on peut très bien passer des paramètre au constructeur, en les définissant à la méthode initialize, et en les passant via l'opérateur 'new'
La syntaxe d'appel de méthode :
[nom de l'objet].[nom de la méthode]
Je vous conseille d'essayer de faire de nouvelles classes dans un projet vierges (script aussi), pour vous habituer à la mécanique.
Si vous avez fait l'essai avec l'exemple de la classe rectangle, d'accéder directement aux attributs de la classe, comme pour appeler une méthode. Vous avez pu constater qu'une erreur été généré, informant qu'aucune méthode correspond au nom de l'attribut.
Par défaut, un attribut de classe est privé à celle-ci, il ne peut être utilisé que dans les méthodes de la même classe. Cependant, il existe un moyen pour rendre accessible un attribut :
il suffit d'utiliser ces commandes :
attr_reader
attr_accessor
attr_reader, permet de rendre un attribut publique en lecture, alors que attr_accessor permet de le rendre publique en lecture et écriture.
Exemple :
| (Ruby) | |
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
class Rectangle
attr_reader :largeur attr_accessor :longueur def initialize @largeur = 0 @longueur = 0 end def changer_largeur(param_largeur = 0) @largeur = param_largeur end def changer_longueur(param_longueur = 0) @longueur = param_longueur end def calculer_perimetre return ( @largeur * 2 ) + ( @longueur * 2 ) end def calculer_surface return @largeur * @longueur end end |
Comme vous le constatez, il faut mettre ':' et le nom de la variable sans le préfixe de porté '@'.
Maintenant vous pouvez directement lire et modifier les attributs de classe, de cette manière :
| (Ruby) | |
| 1 2 3 4 5 6 7 8 9 10 11 12 13 |
un_rectangle = Rectangle.new un_rectangle.changer_largeur(6) un_rectangle.changer_longueur(9) print un_rectangle.largeur print un_rectangle.longueur un_rectangle.longueur = 12 print un_rectangle.longueur print un_rectangle.calculer_perimetre print un_rectangle.calculer_surface |
Cependant, évitez au maximum de rendre publique les attributs de classe, préférez des méthodes permettant de les modifier ou de les récupérer.
