La programmation objet

Définition

La programmation orientée objet (POO) désigne un paradigme de programmation, c’est-à-dire une façon d’organiser ses idées et d’écrire du code source pour exprimer ces idées. Ruby est un langage fortement, pour ne pas dire totalement orienté objet (OO). On oppose en général la POO à la programmation classique procédurale.

Le principe de base de la POO est de regrouper dans un même ensemble les données, et les traitements opérables sur ces données ou à l’aide de ces données. Ces ensembles, ou entités, sont des classes. Elles servent à exprimer de façon élégante un concept du monde réel sous forme de code. Elles servent ensuite plus concrètement à donner corps à des cas particuliers, basés sur le concept général exprimé au travers de la classe. Ces formalisation concrètes sont des objets, et c’est avec eux qu’un programme fait l’essentiel de son travail. Chaque objet est indépendant, dans le sens où il possède sa propre identité, ses particularismes… mais il n’est pas forcément solitaire et/ou autonome. On peut ainsi faire interagir des objets, les rendre mutuellement dépendants, etc. Même les modifier au cours de leur existence !

Par exemple, on peut vouloir exprimer le concept très général de « voiture » dans un programme en Ruby. On veut définir ce qu’est une voiture en général, mais on veut aussi (et surtout) que cette définition générale nous permette de créer de vraies voitures, à notre guise, et que chacune de ces voitures ai des caractéristiques propres. Il faudra donc non seulement exprimer ce qu’une voiture est pour nous, mais aussi définir quelles actions cette voiture générique peut mener, dans quel(s) cadre(s), avec quel(s) moyens. De sorte que les voitures concrètes qu’on créera grâce à notre modèle générique pourront agir, voire interagir entre elles.

On crée d’abord une classe générique Voiture, dans laquelle on dresse quelques grandes caractéristiques communes à toutes les voitures. Ainsi, une Voiture a forcément des places, pour le conducteur et les passagers… Une Voiture peut démarrer, rouler, tourner, s’arrêter… chacune de ces actions étant également vue comme très générale : on ne cherche pas encore à savoir si la voiture démarre avec un moteur à essence ou un moteur électrique, à l’aide d’une clé classique ou d’un badge magnétique, etc.

Par la suite, on pourra créer une voiture particulière, un « exemplaire » basé sur notre modèle Voiture, mais avec ses propres valeurs et son autonomie de fonctionnement.

Une formalisation simple de cet exemple sous forme de code Ruby pourrait être la suivante :


 class Voiture

   # On doit pouvoir spécifier le nombre de places.
   @places

   # Une voiture est à l'arrêt par défaut.
   @enMarche = false;

   # Initialize est activé lorsqu'on créé 
   # une instance de la classe Voiture, 
   # c'est-à-dire lorsqu'on se fabrique un 
   # exemplaire particulier du modèle général 
   # qu'est la classe Voiture.
   def initialize(places = 4)
     # Combien de places dans cette voiture ?
     # Il y en a quatre par défaut, mais on
     # pourra choisir un autre nombre.
     @places = places

     puts "Nouvelle voiture créée." 
     puts "Elle a #{@places} places !" 
   end

   # Toutes les méthodes qui suivent sont les 
   # actions que toute voiture concrète peut 
   # entreprendre.
   def demarrer
     @enMarche = true;
     puts "La voiture a démarré..." 
   end

   def arreter
     @enMarche = false;
     puts "La voiture vient de s'arrêter." 
   end

   def rouler
     # ...
   end

   def tourner
     # ...
   end

   # Toutes les infos utiles
   def infos
     puts "La voiture a #{@places} places." 
     if @enMarche
       puts "Elle est en marche !" 
     else
       puts "Elle est à l'arrêt." 
     end
     puts
   end

 end

 # On créé une première voiture bien réelle
 # à l'aide du modèle générique Voiture.
 voitureDeBase = Voiture.new
 # Examinons notre voiture...
 voitureDeBase.infos

 # Voici une seconde voiture, bien différente.
 petiteVoiture = Voiture.new(2)
 petiteVoiture.demarrer
 petiteVoiture.infos

Une fois exécuté, ce programme en ruby donne le résultat suivant :

Nouvelle voiture créée.
La voiture a 4 places.
Elle est à l'arrêt.

Nouvelle voiture créée.
La voiture a démarré...
La voiture a 2 places.
Elle est en marche !

Cet exemple est très simple mais illustre ce qu’est l’orientation objet. Il s’agit de rendre sous forme cohérente un concept réel, en créant d’abord un « quelque chose » général, qui servira de modèle pour construire du particulier. En soi, le « quelque chose » ne fait rien, il n’agit pas : il ne fait que préparer le terrain, établir des définitions. Pour ce faire, les langages de programmation orientée objet utilisent des variables, pour stocker des valeurs ; des méthodes, pour définir des actions se servant des variables ou les modifiants…

Le paradigme objet apporte de nombreuses autres choses, à découvrir en commençant plus concrètement la POO.