Programmation objet

Voici l'interface de la classe Voiture :

Compteur et Immat sont les attributs de la classe.

Nouvelle, Initialiser, Rouler et AfficherAttributs sont les méthodes de la classe.

Rouler et AfficherAttributs sont des procédures, ChangerPneu est une fonction et la méthode Nouvelle est une méthode spéciale dont la présence n'est pas obligatoire et que l'on appelle le constructeur de la classe. Nous verrons quel est son rôle un peu plus loin.

Comme vous pouvez le constater, le code des méthodes ne figure pas dans l'interface. On y met simplement les en-têtes.

Voici l'implémentation de la classe Voiture :

• La méthode Nouvelle est le constructeur de la classe. Elle permet de créer une nouvelle instance de la classe Voiture en donnant une valeur à son immatriculation (la valeur du paramètre Im). Sans constructeur, il aurait été nécessaire d'utiliser la méthode Create, qui fonctionne pour n'importe quelle classe. Mais Create ne permet pas d'initialiser immédiatement les attributs de l'instance générée. Le constructeur est donc une sorte de méthode Create paramétrée.
• La méthode Rouler augmente le compteur d'une voiture du nombre de kilomètres défini par le paramètre Km, sauf s'il est nécessaire de changer les pneus. Dans ce dernier cas, elle affiche le message « Vos pneus sont usés ! ».
• La méthode ChangerPneu est une fonction booléenne qui retourne la valeur true, si et seulement si le nombre de kilomètres de la voiture est supérieur ou égal à 10 000.
• La méthode AfficherAttribut affiche les valeurs des attributs d'une voiture (immatriculation et compteur) dans les zones de texte prévues à cet effet.

Les en-têtes des méthodes sont identiques aux en-têtes définis dans l'interface, sauf que le nom de chaque méthode est précédé du nom de la classe : Voiture.Nouvelle, Voiture.Rouler, Voiture.ChangerPneu…

C'est de cette manière que l'on associe une méthode à sa classe dans la partie Implementation.

Les méthodes qui commencent par « Voiture. » sont celles de la classe Voiture.

Dans le corps des méthodes, on remarque que les attributs de la classe ainsi que les appels de méthodes de la classe ne sont pas précédés du nom d'une instance de cette classe.

Par exemple, dans le corps du constructeur, les attributs Immat, Compteur ne sont pas précédés par le nom d'une instance.

Dans la méthode Rouler, on appelle les méthodes ChangerPneu et Afficher. Mais elles ne sont apparemment appliquées à aucune instance de la classe Voiture !

En fait, cette instance est implicite : c'est l'instance à laquelle sera appliquée la méthode. On ne la connaît donc pas lorsque l'on écrit le code d'une méthode. Dans tout le corps d'une méthode, il faut donc imaginer que le nom de cette instance figure à gauche des attributs et des méthodes de la classe.

Par défaut, les attributs non précédés du nom d'une instance qui figurent dans le corps d'une méthode de la classe Voiture sont interprétés comme des attributs de la classe Voiture.

C'est la raison pour laquelle les noms des zones de textes Zt_Immat et Zt_Compteur sont précédés par Form1 dans le corps de la procédure AfficherAttribut.

Sinon, ils auraient été interprétés comme des attributs de la classe Voiture, ce qui aurait généré une erreur de compilation.

Rappelons-nous (voir cours I sur la programmation objet) que Form1 est une instance de la classe TForm1 qui représente le formulaire d'une application. Les attributs de cette instance sont les différents composants du formulaire. En particulier, la zone de texte Zt_Immat, doit donc être désignée par Form1.Zt_Immat en dehors d'une méthode de la classe TForm1.

Bt_CreerClick est la procédure évènementielle associée au bouton Nouvelle Voiture.

Dans le corps de cette procédure, on commence par lire l'immatriculation depuis la zone de texte Zt_Immat. Cette chaîne de caractères est affectée à la variable locale immat.

L'instruction suivante génère une instance de Voiture avec immat comme immatriculation, en faisant appel à la méthode Nouvelle, c'est-à-dire au constructeur de la classe.

Puis les attributs de la nouvelle voiture sont affichés en appliquant la méthode AfficherAttributs à l'instance LaVoiture.

Bt_RoulerClick est la procédure évènementielle associée au bouton Rouler.

Dans le corps de cette procédure, on commence par lire la distance à parcourir depuis la zone de texte Zt_Distance. Cet entier est ensuite affecté à la variable locale d.

Ensuite, on fait rouler la voiture pendant d kilomètres en appliquant la méthode Rouler à LaVoiture.

La déclaration d'une propriété simple définit son nom, son type ainsi que le nom d'un accesseur en lecture et, optionnellement, celui d'un accesseur en écriture.

Si l'accesseur en écriture n'est pas donné, la propriété sera en lecture seule (l'affectation d'une valeur à la propriété provoquera une erreur de compilation).

Une propriété avec accesseur en écriture se déclare comme suit :

 property nomP : typeP read nomAL write nomAE;

où nomP, typeP, nomAL et nomAE désignent respectivement le nom de la propriété, son type, le nom de l'accesseur en lecture et le nom de l'accesseur en écriture.

Pour déclarer une propriété en lecture, on omet simplement la déclaration de l'accesseur en écriture comme ceci :

 property nomP : typeP read nomAL;

L'accesseur en écriture est une méthode qui sera automatiquement appelée chaque fois qu'une expression quelconque sera affectée à la propriété. Il est défini comme une procédure avec un en-tête de la forme suivante :

 procedure nomAE (v: typeP);

La valeur de l'expression affectée sera automatiquement transmise au paramètre v lors de l'appel.

L'accesseur en lecture, quant à lui, est une fonction sans paramètre retournant une valeur de même type que la propriété :

 function nomAL () : typeP;

Cette fonction sera exécutée chaque fois que la propriété sera utilisée. C'est-à-dire que chaque fois que la propriété apparaît dans une expression, il faut imaginer que l'appel de l'accesseur en lecture figure à la place.

Notez bien qu'une propriété ne permet de stocker aucune valeur dans un objet. Pour cela, il faut prévoir un attribut (en accès privé de préférence, sinon cela n'a aucun intérêt !). L'accesseur en écriture ira a priori modifier cet attribut avec la valeur qui lui sera donnée et l'accesseur en lecture retournera simplement sa valeur. Mais cela n'est que théorique car les accesseurs sont des méthodes quelconques. Elles sont donc libres de faire ce qu'elles veulent !

Un exemple de classe utilisant des propriétés simples est donné plus bas.

La déclaration des propriétés tableaux suit à peu de chose près le même principe, à part qu'il faut à présent ajouter des informations sur la manière d'indicer les éléments.

Contrairement aux tableaux classiques, les indices des propriétés tableaux peuvent être de type quelconque. On ne précise donc pas un indice de début et un indice de fin, mais simplement le type des indices :

 property nomP [TypeI]: typeV  read nomAL write nomAE;

TypeI représente ici le type des indices et typeV le type des éléments.

L'accesseur en lecture possède à présent un paramètre qui définit l'indice de l'élément auquel on veut accéder :

 function nomAL (i : TypeI) : typeV;

De même pour l'accesseur en écriture :

 procedure  nomAE (i : TypeI; V : typeV);

Depuis l'extérieur de la classe, l'élément d'indice i d'un objet o est désigné par o.nomP[i], comme si la propriété nomP était un attribut de type tableau.

Comme tout est géré par les accesseurs, les données de ce « tableau virtuel » peuvent être en réalité stockées dans toute autre chose qu'un tableau. Par exemple, dans une liste (voir le cours sur les types structurés).

D'autre part, les propriétés tableaux ont la particularité de pouvoir être implicites. C'est-à-dire que l'on pourra écrire o[i] au lieu de o.nomP[i].

Il suffit pour cela de déclarer la propriété nomP comme étant la propriété par défaut de la classe en ajoutant le mot-clé default à la fin de la déclaration :

 property nomP [TypeI]: typeV  read nomAL write nomAE; default

Bien entendu, il ne peut y avoir qu'une seule propriété par défaut dans une classe donnée.

Je pense que tout cela sera plus clair avec un exemple. En voici un.

Supposons, par exemple, que s soit un objet de la classe TStock ; alors s.En_Stock['Samsung Q45'] nous dira combien il reste de « Samsung Q45 » dans le stock s. Il s'agit donc d'une propriété tableau indicée par des chaînes de caractères (le libellé d'un article donné) et dont les éléments sont des entiers (quantité de chaque article).

Voici la déclaration de la propriété En_Stock :

property En_Stock [Libelle : String] : integer
        read GetEnStock write SetEnStock; default;

Nous l'avons définie comme propriété par défaut, ce qui nous permet le raccourci d'écriture s['Samsung Q45'], au lieu de s.En_Stock['Samsung Q45'].

Les données de la propriété En_Stock sont mémorisées dans deux attributs privés : LesLibelles et LesQuantites. Le premier contient les noms des articles présents dans le stock et il est déclaré comme suit :

 LesLibelles : array [1 .. MAX_ARTICLE] of String;

Le deuxième contient la quantité de chaque article. C'est donc un tableau d'entiers. Nous le déclarons de la manière suivante :

 LesQuantites : array [1 .. MAX_ARTICLE] of integer;

Et nous prenons les conventions suivantes :

• les valeurs du tableau LesLibelles sont toutes distinctes. Autrement dit, un même article ne peut pas se retrouver plusieurs fois dans ce tableau ;
• la quantité d'un article donné est définie par LesQuantites[i], où i est l'indice de son libellé dans le tableau LesLibelles. Par exemple, si LesLibelles[3] contient « Samsung Q45 », la quantité de Samsung Q45 dans le stock sera donnée par LesQuantites[3] ;
• un article dont le libellé figure dans le tableau LesLibelles existe dans le stock. Il y en a donc nécessairement une quantité non nulle. Cela signifie également que le tableau LesQuantites ne contiendra toujours que des nombres strictement positifs.

Grâce aux propriétés, tout ceci sera totalement transparent à l'utilisateur de la classe, qui pourra facilement ajouter ou retirer des articles du stock en ignorant totalement le travail effectué en arrière-plan par les accesseurs.

Par exemple, pour ajouter dix Samsung Q45 :

 s['Samsung Q45'] := s['Samsung Q45'] + 10;

Pour en retirer 15 :

 s['Samsung Q45'] := s['Samsung Q45'] - 15;

Et cette opération sera sans effet, s'il n'en restait par exemple que 12.

Pour retirer tous les Samsung Q45 du stock :

 s['Samsung Q45'] := 0;

Pour ajouter un nouvel article, on lui affecte une quantité strictement positive. Par exemple, l'instruction

 s['Clé USB Sony 8GB'] := 20;

sert a priori à placer vingt « clés USB Sony 8GB » dans le stock. Si, par hasard, cet article est déjà en stock, l'ancienne quantité sera effacée.

Voici l'interface de la classe Stock :

TStock = class
  strict private

    NArticle :  integer;
    LesLibelles : array [1 .. MAX_ARTICLE] of String;
    LesQuantites : array [1 .. MAX_ARTICLE] of integer;
    Curseur : integer;
    function Indice (Libelle : String) : integer;
    function GetEnStock (Libelle: String) : integer;
    procedure SetEnStock (Libelle : String; n : integer);
    procedure Supprimer (Libelle : String);
    
  public
      property En_Stock [Libelle : String] : integer
        read GetEnStock write SetEnStock; default;
      constructor Nouveau ();
      function ArticleSuivant (): String;
      procedure Debut ();
end;

NArticle contient l'indice du dernier article. Un stock vide se reconnaîtra donc par NArticle = 0 et un stock plein, par NArticle = MAX_ARTICLE.

L'attribut Curseur, ainsi que les méthodes ArticleSuivant et Debut, permettent de parcourir les articles d'un stock avec une boucle. Nous en reparlerons plus loin.

La fonction Indice retourne l'indice, dans le tableau LesLibelles, d'un article de libellé donné. Si cet article est absent, elle retourne la valeur 0.

La procédure Supprimer supprime un article de libellé donné en décalant les éléments suivants vers la gauche (voir le cours sur les tableaux, gestion des tableaux remplis partiellement).

Nous n'allons pas détailler ici l'implémentation de toutes les méthodes de la classe (si cela vous intéresse, consultez le code source du projet Magasin dans le répertoire Exemple-ProgObjet2), mais uniquement les accesseurs de la propriété tableau En_Stock.

Voici l'accesseur en lecture :

function TStock.GetEnStock (Libelle: String) : integer;
var i : integer;
begin
  i := Indice (Libelle);
  If i = 0 then GetEnStock := 0
  else
    GetEnStock := LesQuantites[i];
end;

Et voici l'accesseur en écriture :

procedure TStock.SetEnStock (Libelle : String; n : integer);
var position : integer;
begin
  position := Indice (Libelle);
  If position = 0 then
  begin
    If (NArticle <> MAX_ARTICLE) and (n > 0) then
      begin
         NArticle := NArticle  + 1;
         LesLibelles [NArticle]:=Libelle;
         LesQuantites [NArticle] := n;
      end
  end
  else
    if n >= 0 then  
      if n = 0 then Supprimer (Libelle)
      else LesQuantites [position] := n;

end;

La logique de cette procédure est la suivante :

• nous commençons par repérer la position de l'article ;
• si l'article est introuvable (position = 0), on l'ajoute au stock. Mais cela n'est possible que si la quantité à ajouter est un nombre strictement positif (n > 0) et que le stock n'est pas rempli (NArticle <> MAX_ARTICLE). Si ces deux conditions sont vérifiées, on ajoute l'article dans le stock avec la quantité n associée. Ceci est réalisé en empilant le libellé dans le tableau LesLibelles et la quantité dans le tableau LesQuantites (pour la notion de pile, voir également le cours sur les tableaux, gestion des tableaux remplis partiellement) ;
• si l'article existe, il y a trois possibilités :

• n est négatif : on ne fait rien ,
• n = 0 : on supprime l'article ,
• N > 0 : on affecte la quantité n à cet article.

Dans le dossier Exemple-progObjet2/Magasin, vous trouverez un exemple de projet utilisant la classe stock. Voici son interface graphique :

Voici la procédure évènementielle associée au bouton Commander :

procedure TForm1.BT_CommanderClick(Sender: TObject);
var libelle: string; quantite : integer;
begin
libelle := ZT_LIB.Text;
quantite := StrToInt(ZT_Quantite.Text);
Stock[libelle]:= Stock[libelle]+quantite;
AfficherLeStock ();
end;

Commander un article consiste donc à ajouter la quantité commandée au stock. Le nouveau contenu du stock est affiché à l'écran par la procédure AfficherLeStock, dont nous reparlerons plus loin.

Celle du bouton Vendre suit le même principe. On remplace simplement le + par un - :

procedure TForm1.BT_VendreClick(Sender: TObject);
var libelle: string; quantite : integer;
begin
libelle := ZT_LIB.Text;
quantite := StrToInt(ZT_Quantite.Text);
Stock[libelle]:= Stock[libelle]-quantite;
AfficherLeStock ();
end;

La procédure AfficherLeStock affiche le contenu du stock dans la zone de liste. Elle n'utilise pas les propriétés tableaux et n'est donc pas essentielle pour la compréhension de ce cours. Elle vous servira néanmoins à comprendre l'intérêt de l'attribut Curseur et des méthodes ArticleSuivant et Debut.

La méthode ArticleSuivant permet de parcourir le stock avec une boucle, sans connaître le nombre d'articles (rappelez-vous que NArticle est un attribut privé).

Nous utilisons ici le principe du curseur pour parcourir séquentiellement un ensemble de données (on retrouve par exemple ce principe dans le parcours séquentiel d'un fichier ou dans la lecture d'une table d'une base de données).

Dans notre cas, le curseur est un nombre entier qui définit l'indice du dernier article lu. Il est représenté par l'attribut privé Curseur de la classe Stock.

Comme il s'agit d'un attribut privé, l'utilisateur de la classe ne peut pas agir directement sur lui. Par contre, il dispose de la méthode publique ArticleSuivant, qui lui permet d'avancer le curseur d'un cran. Il s'agit plus précisément d'une fonction qui retourne le libellé de l'article suivant. Voici le code de cette méthode :

function TStock.ArticleSuivant (): String;
begin
  if Curseur = NArticle then ArticleSuivant := 'FIN'
  else
  begin
     Curseur := Curseur + 1;
     ArticleSuivant := LesLibelles[Curseur];
  end;
end;

Si le curseur pointe sur le dernier article (Curseur = NArticle), cela signifie que l'on a parcouru tout le stock. Dans ce cas, la fonction n'avance pas le curseur et retourne simplement la chaîne 'FIN' pour signifier que l'on est arrivé au bout du stock.

Par contre, s'il ne pointe pas sur le dernier article, le curseur est incrémenté et la fonction retourne le libellé de l'article sur lequel il pointe après l'incrémentation. C'est-à-dire le libellé de l'article suivant.

La méthode Debut permet de positionner le curseur au début du stock :

procedure TStock.Debut ();
begin
  Curseur := 0;
end;

Elle doit donc être appelée avant de parcourir le stock avec une boucle.

À présent, voyons le code de la procédure AfficherLeStock :

procedure TForm1.AfficherLeStock ();
var libelle : String; quantite: integer;
begin
  Stock.Debut; ZL_Stock.Clear;
  libelle := Stock.ArticleSuivant ;
  While libelle <> 'FIN' do
  begin
     ZL_Stock.Items.Add(libelle+': '
                        +IntToStr(Stock[libelle]));
     libelle := Stock.ArticleSuivant;
  end;
end;

Tant que l'on n'est pas à la fin du stock (libelle <> 'FIN'), on affiche l'article courant puis on passe à l'article suivant.

Si le stock n'est pas vide, les instructions Stock.Debut et Stock.ArticleSuivant figurant avant la boucle placent le curseur sur le premier élément.

S'il est vide, libelle contiendra la chaîne 'FIN' dès le départ et la boucle d'affichage ne sera pas exécutée.

L'affichage d'une forme donnée est réalisé par la procédure Bt_AfficherClick.

Elle commence par lire le numéro (num) de la forme à afficher, c'est-à-dire l'indice de l'élément du tableau TF dans lequel cette forme est stockée.

TF[num] contient donc un objet de la classe Forme ou un objet de la classe Cercle.

Pour distinguer les deux cas, nous avons utilisé l'opérateur is, qui permet de savoir si un objet appartient à une classe donnée.

Si TF[num] est une instance de la classe Cercle, nous ne pouvons pas appliquer directement la méthode AfficherAttributs pour l'afficher.

En effet, bien que TF[num] contienne un objet de la classe Cercle, il est considéré par le compilateur comme un objet de la classe Forme car le tableau TF a été déclaré comme un tableau de Forme.

Pour forcer le compilateur à interpréter TF[num] comme un objet de la classe Cercle, nous avons utilisé le polymorphisme, qui se traduit en Pascal par l'opérateur as.

TF[num] as Cercle signifie que le compilateur doit interpréter TF[num] comme un cercle. De ce fait, la méthode AfficherAttributs appliquée à cet objet sera bien celle de la classe Cercle.

La génération aléatoire d'un cercle et son stockage dans le tableau TF est réalisée par la procédure Bt_NouveauCercleClick.

Elle illustre un autre aspect du polymorphisme. En effet, lorsque l'on applique la méthode AjouterForme au cercle généré, cela provoque (voir le code de la méthode AjouterForme) son stockage dans un élément du tableau TF.

Or ces éléments sont a priori tous des objets de la classe Forme !

En fait, cela ne pose pas de problème au compilateur car TF ne contient que des pointeurs.

L'instruction TF[NF]:=self ne fait rien d'autre que stocker l'adresse de l'objet dans le tableau TF.