Encapsulation - Modularité

L'encapsulaton est une technique qui permet de masquer le fonctionnement interne d'un objet : les attributs "privés" de l'objet ne sont accessibles qu'à travers des méthodes écrites spécifiquement pour cela.

1. Pourquoi encapsuler ?

Le premier objectif est de donner à l'utilisateur les méthodes de manipulation d'un objet sans expliquer son fonctionnement interne.

la classe Voiture encapsule beaucoup d'informations :

" sous le capot "
Inutile de savoir comment marche la voiture pour l'utiliser
Interface : volant, tableau de bord, changement de vitesses
Implémentation : moteur, transmission, essieu, roues, . . .

Pour un objet composé, il est souvent inutile de donner accès à tous les composants

Eviter la " cascade " de composants

Donner accès simplement à des méthodes utiles

Exemple : Au lieu de 4 ligne des codes

maVoiture.roueARG.pneu.gonfler;
maVoiture.roueAVG.pneu.gonfler;
maVoiture.roueARD.pneu.gonfler;
maVoiture.roueAVD.pneu.gonfler;

On ecrira une méthode spécifiqiue

Procedure Voiture.VerifierPressionPneus;
Begin
roueARG.pneu.gonfler;
roueAVG.pneu.gonfler;
roueARD.pneu.gonfler;
roueAVD.pneu.gonfler;
end ;

Le second objectif est de protéger l'objets contre des "usages abusifs"

Exemple : écrire les méthodes

Procedure Voiture.Acceler
Procedure Voiture.Freiner

pour modifier la vitesse du véhicule, et interdire de modifier directement l'attribut vitesse

2. Comment encapsuler ?

Définir avec les mots clés public, private et protected la portée des attributs et des méthodes

Public
valeur par par défaut : attributs et méthodes accessibles partout

Private
attributs et méthodes accessibles uniquement par des méthodes de la classe

Protected
attributs et méthodes accessibles aux méthodes des classes hértitant de cette classe

3. Exemples d'encapsulation

TPneu = Class(Tobject)
Private
   pression : real ;
   const MAX_PRESSION = 500 ;
Public
   procedure gonfler ;
   procedure degonfler ;
   function lirePression : real ;
end ;

procedure TPneu.gonfler;
const INC_PRESSION = 10 ;
begin
if pression < MAX_PRESSION- INC_PRESSION then pression = pression + INC_PRESSION
end ;

procedure TPneu.degonfler;
const DEC_PRESSION = 20 ;
begin
if pression >= DEC_PRESSION then pression = pression - DEC_PRESSION
end;

function TPneu.lirePression : real ;
begin
lirePression = pression
end ;

Impossible de modifier directement la pression du pneu

type TVehicule = Class(Tobject)
Protected
PosX, PosY, PosZ : real ;
dX, dY, dZ : real ;
Public
procedure tournerAgauche () ;
procedure tournerAdroite () ;
procedure avancer()
fonction vitesse : real ;
end;
...

4. Modularité

La définition d'unités permet de regrouper le source d'une ou plusieurs classes dans un seul fichier. Cette unité pourra ensuite être utilisée dans différents programmes qui auront ainsi accès à ces classes.
Une unité est définie par le mot clé Unit placé en début de fichier; on déclare dans la zone Interface la déclaration des classes "visibles" de l'unité, et on place les méthodes dans la zone Implementation de l'unité
Pour utiliser le code se trouvant dans une unité, il faut, depuis le programme principal (ou une autre unité) utiliser le mot clé Uses pour déclarer les unités dont on a besoin

Exemple

Unit UVoiture ;
Uses UVehicule ; //L'unité UVoiture a besoin du code défini dans l'unité UVehicule

Interface
Type Tvoiture = Class (TVehicule)
.... //déclaration de la classe TVoiture

Implementation

.... //code des méthodes de la classe TVoiture