Initiation à la
Programmation Orientée Objet

Auteur : Åvygeil


I) Quelques définitions

Un programme informatique est composé de 2 parties :
[list]- La 1ere partie consiste à décrire les structures de données, ainsi qu'à définir les opérations que l'on pourra exercer sur elles.
- La 2eme partie consiste à créer ces structures de données à partir de leur description, et à les faire interagir entre elles selon les opérations que l'on a défini.[/list:u]

Le paradigme de la Programmation Orientée Objet, ou POO, consiste à regrouper la définition des données et des opérations qui leurs sont associées dans une entité appelée «classe», qui servira à construire des «objets» dit «instances» de cette classe, avec un état et un comportement bien définis par cette classe.

Nous allons illustrer, au travers d'un exemple en Ruby, car c'est le langage informatique utilisé dans RPG Maker XP, les différents principes de la POO :
[list]- Classe
- Objet
- Encapsulation des données
- Heritage
- Référence[/list:u]

II) Classe

La création des classes du programme correspond à la 1ere partie où l'on définit les structures de données et les opérations sur elles.
Dans une classe, on définit des attributs qui servent à décrire l'état, et des méthodes qui décrivent le comportement d'un objet instance de la classe.

Nous allons implémenter en Ruby une classe Voiture. L'état des objets créés à partir de cette classe sera caractérisé par un attribut vitesse, et le comportement par la faculté d'accélérer et de donner sa vitesse.

Créez un nouveau projet, nommé «Tutorial POO» par exemple, et créez un nouveau script nommé «Voiture» au dessus du script Main.

Commençons par définir une classe vide, grâce au mot-clé class :

Code: Tout sélectionner

class Voiture

end


Pour que notre classe Voiture puisse générer des objets, il faut créer une méthode spéciale nommée «initialize» : celle-ci se chargera d'initialiser la vitesse des voitures à une valeur souhaitée, où à 0 par défaut.
Dans la classe Voiture, tappez :

Code: Tout sélectionner

def initialize(v = 0)
    @vitesse = v
end


Observons la syntaxe de plus près :
[list]- On définit une méthode grâce au mot-clé def.
- A une méthode, on peut passer des paramètres (ici la vitesse initiale).
- A un paramètre, on peut donner une valeur par défaut (ici 0).
- Les attributs sont précédés du symbole @.[/list:u]

Créons à présent la méthode qui va permettre aux voitures d'accélérer :

Code: Tout sélectionner

def accelere(a)
    @vitesse += a
end 


Observons la syntaxe de plus près :
[list]- += est une opération qui permet d'ajouter à la vitesse le nombre passé en paramètre.[/list:u]

Finissons par la méthode qui permet à la voiture de donner sa vitesse actuelle, c'est à dire son état.
Ce genre de méthode est appelé généralement «to_s» en Ruby, car elle renvoie un objet String, une chaîne de caractères.

Code: Tout sélectionner

def to_s
    return "Ma vitesse est #{@vitesse} km/h"
end 


Observons la syntaxe de plus près :
[list]- Le mot-clé return permet de renvoyer l'objet placé juste derrière.
- Un objet String est créé grâce à des guillemets.
- Les objets entre #{...} sont directement incorporés dans la chaîne de caractères.[/list:u]

Récapitulons notre 1ere classe :

Code: Tout sélectionner

class Voiture

    # Méthode d'initialisation de la voiture.
    def initialize(v = 0)
        @vitesse = v
    end

    # Méthode d'accélération de la voiture.
    def accelere(a)
        @vitesse += a
    end

    # Méthode qui renvoie une description de la voiture.
    def to_s
        return "Ma vitesse est #{@vitesse} km/h"
    end

end


Quelques remarques :
[list]- Les lignes commençant par un # sont des commentaires non pris en compte lors de l'execution du programme. Usez et abusez-en pour commenter votre code.
- Indentez et espacez votre code pour le rendre plus lisible.[/list:u]

III) Objet

Maintenant que nous avons créé notre classe Voiture, nous allons enfin pouvoir créer des objets instances de la classe Voiture, que nous appellerons simplement les Voitures par abus de langage.

Créons une Voiture de vitesse initiale égale à 0, en tappant dans le script Main, juste après begin

Code: Tout sélectionner

$voiture1 = Voiture.new(0)


Observons la syntaxe de plus près :
[list]- Les variables précédés d'un $ sont globales : elles peuvent être utilisées dans tout le programme.
- La méthode new appelle la méthode initialize de la classe Voiture avec les paramètres qui suivent.
- La vitesse par défaut étant de 0, on aurait pu n'écrire que Voiture.new.[/list:u]

Nous allons maintenant pouvoir tester les différentes fonctionnalités de notre nouvelle Voiture.

Créez un évènement, et dans ses commandes, insérez le script

Code: Tout sélectionner

print $voiture1


La méthode print appelle directement la méthode to_s de la Voiture et affiche dans une fenêtre la chaîne de caractères obtenues.

Testez l'évènement : une fenêtre s'ouvre avec marqué à l'intérieur : «Ma vitesse est 0 km/h».

Créez un autre évènement, et insérez dans ses commandes le script

Code: Tout sélectionner

$voiture1.accelere(10)


On voit que pour appeler la méthode d'un objet, on utilise la notation objet.methode.
Testez le nouvel évènement pour faire accélérer la voiture de 10 km/h autant de fois que vous le souhaitez, et vérifiez que la vitesse augmente bien à l'aide du 1er évènement.

IV) Encapsulation des données

Nous allons à présent accéder à l'attribut vitesse de $voiture1 avec la notation objet.attribut ; tappez juste après la construction de $voiture1 :

Code: Tout sélectionner

$voiture1.vitesse


Lancez le jeu : plantage ! et c'est normal.

On ne peut pas avoir directement accès aux attributs d'une classe lorsque l'on est en dehors de cette classe.
Ceci est appelé l'encapsulation des données.
Pour avoir accès à l'attribut vitesse, on doit passer par une méthode dite d'accès en lecture, que l'on implémente à l'intérieur de la classe Voiture de manière canonique ainsi :

Code: Tout sélectionner

def vitesse
    return @vitesse
end


Ainsi, quand vous écrirez $voiture1.vitesse, vous n'accèderez pas directement à l'attribut vitesse ; vous appellerez la méthode vitesse qui va renvoyer la vitesse de l'objet courant, l'objet qui appelle la méthode.

En Ruby, il existe un raccourci très utile ; au lieu de tapper la méthode d'accès en lecture, on tappe en haut de la classe :

Code: Tout sélectionner

attr_reader :vitesse


qui sera interprété comme la méthode d'accès en lecture.

De la même manière, si l'on tappe dans le script Main

Code: Tout sélectionner

$voiture1.vitesse = 10


on court au plantage.

On doit alors implémenter dans la classe Voiture une méthode dite d'accès en écriture :

Code: Tout sélectionner

def vitesse=(v)
    @vitesse = v
end


Ainsi, l'accès à vitesse n'est pas direct car la ligne de code est interprétée comme un appel à la méthode vitesse=.

Et de la même manière, on peut remplacer ce code par

Code: Tout sélectionner

attr_writer :vitesse


qui sera interprété comme la méthode d'accès en écriture.

On peut également condenser ces 2 méthodes d'accès en tappant

Code: Tout sélectionner

attr_accessor :vitesse


V) Héritage

Le concept d'héritage est étroitement lié à la conception orientée objet.
On dit qu'une classe A hérite ou dérive d'une autre B lorsque, conceptuellement, A est une spécification de B.
Ainsi, A aura accès aux mêmes méthodes que B, et également aux siennes plus spécifiques, alors que B n'aura pas accès aux méthodes de A.
On dit que A est une sous-classe de B, et B une super-classe de A.

- Créons par exemple une sous-classe de Voiture.
Dans le script Voiture (ce n'est pas obligatoire, c'est simplement par soucis de place...) créez une nouvelle classe Porshe dérivant de Voiture.

Code: Tout sélectionner

class Porshe < Voiture

end


Le < définit le lien d'héritage entre Voiture et Porshe.

Passons à présent à la méthode constructeur.

Code: Tout sélectionner

def initialize(v,p)
    super(v)
    @puissance = p
end


super appelle le constructeur de la super-classe Voiture.

- On peut également redéfinir des méthodes ; par exemple la méthode accelere : au lieu d'ajouter «a» à la vitesse, on la multiplie en plus par la puissance.
Tappez dans la classe Porshe

Code: Tout sélectionner

def accelere(a)
    @vitesse = (@vitesse+a)*@puissance
end


Ainsi, si on tappe dans le script Main

Code: Tout sélectionner

$porshe1 = Porshe.new(0,10)
$porshe1.accelere(10)


on appelle la méthode accelere de Porshe et non celle de Voiture.
Testez le en modifiant les 2 évènements créés plus haut.

Une autre manière, plus difficile à appréhender, est d'utiliser le mot clé super ainsi :

Code: Tout sélectionner

def accelere(a)
    super(a)
    @vitesse *= @puissance
end


Déjà vu dans la méthode initialize, le vrai rôle de super est d'appeler la méthode ayant le même nom au sein de la super-classe.

L'opérateur *= multiplie la vitesse par la puissance.

Mais attention avec les redéfinitions de méthodes, car plus jamais une Porshe ne pourra appeler la méthode accelere de Voiture.

VI) Référence

Voilà un petit point qui risque de faire bugger un algorithme bien rôdé, si l'on n'y prend pas garde...
Un objet est définit par son état, son comportement, mais aussi par son identité, sa référence, en gros son adresse en mémoire ; et une variable contient en faite non pas l'objet directement, mais la référence vers cet objet.

Par exemple, quand on écrit

Code: Tout sélectionner

$voiture1 = Voiture.new(0)


Voiture.new(0) crée un objet puis renvoie la référence de cette objet qui est ensuite stockée dans la variable $voiture1.

Les problèmes surgissent si l'on fait par exemple

Code: Tout sélectionner

$voiture2 = $voiture1
$voiture1.accelere(10)


car celà va faire accélérer $voiture1 ET $voiture2, car $voiture2 contient une référence vers la même Voiture que $voiture1... ce qui n'est sûrement pas le but recherché...

Un autre exemple, qui va permettre de mieux visualiser le problème :

Vous avez peut-être remarqué que l'on ne peut avoir 2 fois le même personnage au sein d'une équipe... celà peut-être génant si, pour l'accompagner, votre héro doit engager des soldats qui seront tous identiques...

[list]- Initialisez l'équipe de départ avec le héro seul et testez en créant un évènement qui rajoute votre héro à l'équipe... non non, votre héro ne se démultiple pas...
- Pour régler ceci, allez dans le script Game_Party à la ligne 106 ; la méthode add_actor(actor_id) permet de rajouter à l'équipe un Game_Actor selon actor_id (en gros un numéro parmi les Game_Actor en réserve...) ; à la ligne 110, on voit que le Game_Actor est effectivement ajouté si l'équipe ne contient pas déjà 4 Game_Actor, et si il n'y est pas déjà inclus : Mettez and not @actors.include?(actor) en commentaire.
- A présent, votre héro peut se multiplier, testez le...
- Maintenant, créez un évènement qui lance un combat, et battez vous avec votre équipe de héros.
- Laissez un personnage se faire toucher : tous les personnages perdent de la vie ! Que se passe-t-il ?[/list:u]

En gros, l'équipe est un tableau de Game_Actor ; seulement à la ligne 112 @actors.push(actor) ajoute au tableau une référence vers toujours le même Game_Actor...
Comment régler celà ? en n'ajoutant non pas une référence vers l'objet, mais une référence vers un clone de l'objet : il a les mêmes valeurs aux attributs au moment de sa création, mais ce n'est pas le même objet !
Créons une méthode que l'on nommera «clone» à l'intérieur de la classe Game_Actor :

Code: Tout sélectionner

def clone
    return Game_Actor.new(self.id)
end


Cette méthode crée un Game_Actor ayant le même id et donc les mêmes caractéristiques, au moment de sa création, que l'objet courant, et renvoie une référence vers ce nouveau Game_Actor.
Ensuite dans la méthode add_actor de Game_Party, au lieu d'ajouter un Game_Actor à l'équipe par

Code: Tout sélectionner

@actors.push(actor)


ajoutez un clone à la place

Code: Tout sélectionner

@actors.push(actor.clone)


A présent, tous les héros ont leurs vies propres.

VII) Conclusion et références

Ce tutorial a pour but premier d'initier les Makers à la Programmation Orientée Objet ; en effet, tous les principes qui y sont énoncés sont valables pour tous les langages orientés objet, tel que le C++, Java, et le langage qui nous intéresse le plus : le Ruby. Il montre aussi que programmer, ce n'est pas faire bouger des sprites à l'écran : on ne voit pas de voiture rouler à l'écran, et pourtant elle existe car on agit dessus.

Son second but est d'aborder la syntaxe du Ruby, car concevoir des classes ne sert à rien si on ne peut pas les coder... Cependant beaucoup de points de conception et de syntaxe spécifiques au Ruby ne sont pas abordés ici.

Ce tutorial n'a pas pour prétention de pouvoir transformer tous les Makers en scripteurs du jour au lendemain ; certains n'arriveront même jamais à comprendre le principe même de la programmation, et les autres auront à étudier les scripts et à faire des essais par eux-même.

Pour toute question sur ce tutorial ou sur le langage Ruby :
[list]- Envoyer un MP à Åvygeil.
- Ou consulter le site http://www.rubycentral.com/book/[/list:u]

un autre truc pour le Ruby:pour l'executer il faut taper en lign de commande:
ruby /hom/kilian/test.rb
(ou cd ~/
ruby test.rb je suis pas sur)

Merci pour ce tutoraial qui sera dans le manuel et sur le site

Merci je commence le Ruby et sa ma permis de comprendre beaucoup de choses ton tutoriel