❤ 0 Sommaire
Ruby
Les variables
Les tableaux
Les booléens et les calculs logiques
Structure de if
Structure de case
Boucles loop do et while
Boucle for
Fonctions et procédures
>> POO - Classes et objets <<
RGSS
Débuter avec le RGSS
Module Input
Bitmap, Color, Sprite
Structure de base des classes Scene et Window
[Ruby] Cours n°9 : POO - Classes et Objets
Voilà voilà, on y est. La Programmation Orientée Objet, la POO. Le meilleur outil 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 conseille donc de prendre du temps à bien relire chaque chose jusqu'à le comprendre. Et surtout à la moindre question n'hésitez pas à la poser.
On va donc commencer par la 'classe', qui est tout bêtement l'abstraction d'un objet. Oulah, vous êtes déjà perdus ! 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 :
Citation: 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 :
Citation: 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 :
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 :
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 :
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 :
1
2
3
4
5
6
7
8
9
10
11
12
| 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 publics les attributs de classe, préférez des méthodes permettant de les modifier ou de les récupérer.
Source
- Tonyryu, "[Ruby] Cours n°9 : POO - Classes et Objets", TonyryuDev, écrit le 2 août 2013 [consulté le 4 juillet 2021], https://web.archive.org/web/20181129103902/http://www.tonyryudev.com/joomla3/index.php/menu-mes-developpements/menu-cours-ruby-rgss/10-ruby-cours-n-9-poo-classes-et-objets
Ce tutoriel a été posté avec l'accord de son auteur.
| 
Chat
