Editions ENI Livres | Vidéos | e-Formations
Concept objet en Delphi
Introduction à la programmation orientée objet
Il s’agit d’une approche différente de la programmation procédurale. Si un programme informatique écrit de manière procédurale est la réponse à la question "que veut-on faire ?" le même programme écrit de manière orientée objet répond à la question "de quoi parle-t-on ?". On découpe fonctionnellement le programme à réaliser par rôles, par concept ou par entités physiques modélisées dans le programme. Les entités ainsi définies sont appelées "objet".
Nous allons étudier dans ce chapitre l’exemple d’une application de gestion de location de véhicules. Rapidement, on peut énumérer quelques rôles et entités :
-
Le véhicule (quoi ?)
-
Les utilisateurs de l’application (client ou administrateur) (qui ?)
-
L’agence de location (où ?)
-
La réservation de location (date de début/date de fin) (quand ?)
En général, on modélise les objets à travers le langage UML qui permet de décrire schématiquement la structure, le comportement de chaque objet. On décrit aussi en UML le comportement des différents objets les uns par rapport aux autres. Au final...
Principes de la programmation objet
1. Les champs
Un champ est une variable interne à un objet. Comme toute variable, ce champ possède un type (entier, chaîne de caractères ou même une autre classe) et est manipulé par les méthodes de la classe à laquelle il appartient.
Un champ peut être :
-
un champ d’instance, qui est propre à chaque objet.
-
un champ statique ou champ de classe qui est propre à toute la classe. La valeur de cette variable est la même pour toutes les instances de la classe.
2. Les méthodes
Les méthodes sont les routines qui permettent de manipuler les champs de la classe. En fonction d’un certain état d’entrée A, selon la méthode exécutée M, l’objet se retrouve dans un autre état B.
L’ensemble formé par les champs et les méthodes est appelé "membres de la classe".
Une méthode peut être :
-
une méthode d’instance, n’agissant que sur un seul objet (instance de la classe) à la fois,
-
une méthode statique ou méthode de classe qui n’agit pas sur des variables d’instance mais uniquement sur des variables de classe. Elle est indépendante de toute instance de la classe (objet).
3. Encapsulation de données
L’intérêt d’un objet réside dans le fait qu’il rassemble toutes les données (champs) dont il a besoin au sein d’une même classe ainsi que les moyens de les gérer (méthodes). Dans ce principe d’encapsulation, il existe également une notion de visibilité qui permet de masquer ou non certaines données de l’objet que l’on manipule de l’extérieur.
Cela permet de garantir une cohérence des données qui ne pourront être modifiées de l’extérieur qu’à travers les méthodes visibles.
Dans le principe d’encapsulation, il existe deux modes de visibilité :
-
Privé
-
Public
Un membre privé est inaccessible vu de l’extérieur à la classe concernée.
4. Représentation UML et nommage
Voici un exemple de représentation UML (Unified Modeling Language) :
Ci-après est définie la classe TExemple. En général, on définit...
Définition de classe
Une classe est définie par ses attributs, les méthodes qu’elle déclare et la classe de base dont elle hérite. Nous avons vu qu’il existe trois modes de visibilité dont voici l’équivalent Delphi lors de l’implémentation.
|
Visibilité |
Implémentation |
|
publique |
public |
|
protégée |
protected |
|
privée |
private |
Par défaut, si rien n’est spécifié, la classe de base est TObject. Ainsi, en Delphi, chaque classe hérite au minimum de toutes les méthodes et tous les champs publics et protégés de TObject.
Il est préférable de toujours déclarer son constructeur et son destructeur (ces notions sont expliquées dans les prochaines sections), même s’ils ne font rien de plus que les constructeurs et destructeurs hérités.
Ci-dessous est présentée la déclaration d’une classe d’exemple dont le nom est TMyClass.
type
TMyClass = class(TObject)
private
FField1 : integer;
public
function GetField1 : integer;
constructor Create;
destructor Destroy;override;
end; -
Le mot réservé type sert à identifier le début de la déclaration de la classe.
-
Le mot réservé class montre qu’il s’agit de la définition d’une classe. Il est nécessaire pour indiquer la classe de base dont hérite la classe que l’on est en train de définir.
-
Le nom de la classe est TMyClass et on a explicitement défini la classe de base qui est TObject. TObject est écrit entre parenthèses juste après le mot réservé class, ce qui indique l’héritage de TObject. On remarque le séparateur ’=’ entre le nom de la classe et le mot réservé class.
Quand une classe hérite de TObject, l’écriture class(TObject) peut être remplacée par class uniquement : type TMyClass = class.
Cette classe possède :
-
Un champ privé FField1
-
Une méthode publique GetField1
-
Un constructeur Create;
-
Un destructeur Destroy;
On peut considérer une classe comme un modèle ou un moule pour définir...
Mise en pratique - Application pour la location de véhicules
Dans cette section, l’exemple d’une application de gestion de location de véhicules, développée au fil des sections précédentes, est présenté dans le détail.
1. Convention de nommage
Voici quelques recommandations des plus courantes chez les développeurs Delphi :
-
Il est conseillé d’écrire son code source en anglais.
-
Une classe commence toujours par T pour « type ».
-
On essaye d’avoir une classe définie par unité et l’unité qui porte la classe possède le même nom que la classe en commençant par U.
Ainsi, la classe TVehicule sera portée par l’unité UVehicule dans le fichier UVehicule.pas.
Du haut vers le bas, on définit les sections private, protected, public :
TVehicule = class(TObject)
private
...
protected
...
public
...
end; -
Un champ privé ou protégé commence toujours par F, on peut doubler le F pour le nommage, par exemple : FField : integer.
-
Une propriété qui porte un évènement est préfixée par On :
property OnMyEvent : TNotifyEvent read FMyEvent write FMyEvent; -
Les accesseurs méthodes pour une propriété sont préfixés de Get pour le read et de Set pour le write :
property myProp : integer read GetMyProp write SetMyProp; 2. Implémentation
Examinons l’implémentation de chaque classe.
TVehicule
Il s’agit de la classe de base. Telle qu’elle a été représentée dans le schéma UML, elle porte deux champs :
unit UVehicule;
interface
uses VCL.Graphics;
type TVehicule = class(TObject)
protected
FBrand : string;
FColor : TColor;
public
constructor Create(ABrand:string;AColor:TColor);reintroduce;
destructor Destroy;override;
function GetRentalPrice():double;virtual;abstract;
function GetDescription():string;virtual;
end;
implementation
{ TVehicule }
constructor TVehicule.Create(ABrand: string; AColor: TColor);
begin
inherited...Conclusion
Dans ce chapitre ont été abordés les principes de la programmation orientée objet en Delphi, ainsi que les principes de visibilité et de polymorphisme. Un exemple d’implémentation a été vu pour manipuler les différentes notions avec une syntaxe Delphi. Il faut savoir trouver un équilibre entre un découpage trop important et une implémentation monobloc. Malheureusement, seule l’expérience et plusieurs phases de refactoring permettront au développeur d’obtenir une architecture convenable au fil du temps.