Vous êtes sur la page 1sur 3

Chapitre 6 Encapsulation et abstraction

L’encapsulation, abstraction, le polymorphisme, la surcharge et l’héritage font partie intégrante de


la POO et permettent d’élaborer des programmes complexes.

1. Encapsulation

Le principe de l’encapsulation (Information hiding) est de regrouper dans le même objet


informatique les données et les traitements qui lui sont spécifiques. En d’autres termes, les données
et les méthodes qui les manipulent sont regroupées dans une même entité (la classe). Les objets sont
définis par leurs attributs et leurs méthodes. Tous les attributs d'une classe doivent toujours être
privés. Ainsi, on ne peut pas les modifier depuis l'extérieur et ils ne doivent être accessibles depuis
l'extérieur de la classe que par des méthodes comme les accesseurs et les getteurs ou autres
méthodes. L'encapsulation est également appelée masquage de données au niveau de la mise en
œuvre afin d'obliger les développeurs utilisateurs à utiliser uniquement les méthodes.
Exemple l’attribut Solde d’un compte CCP d’un client ne peut donc être modifié sans passer par
une méthode. Cela éviterait une affectation comme Mohamed.solde = 12OOO ;

2. Abstraction

L’abstraction est l’identification des informations spécifiques qui devraient être visibles de
l’extérieur. Elle fait ressortir les caractéristiques essentielles d’un objet qui le distinguent de tous les
autres genres d’objets. Ce qui permet de focaliser sur l'essentiel et de cacher les détails, c'est-à-dire
cacher la mise en œuvre de la classe. L’abstraction est le processus au terme duquel on réalise qu'on
manipule en réalité les données d'un plus haut niveau. Dans l’exemple de la classe Rectangle à la
quelle on peut associer une description générique: ici tous les rectangles sont caractérisés par une
longueur et une largeur auxquelles on peut attacher un même calcul de surface. Du coup on décide
de travailler avec la notion plus abstraite de Rectangle plutôt que de travailler avec une description
intime de la représentation des rectangles. En effet, l’isolement et dissimulation des détails
d'implémentation, ce niveau interne de perception d'un objet n'est pas forcément utile à celui qui
utilise.

3. Polymorphisme

Le polymorphisme est une approche utilisée pour exprimer le comportement commun entre types
d’objets ayant des caractéristiques similaires. Une même opération peut se comporter différemment
selon l’objet sur lequel elle est appliquée. L’héritage est un moyen pour réaliser le polymorphisme à

1
Chapitre 6 Encapsulation et abstraction

travers une hiérarchie d’objets. En effet, le polymorphisme signifie que la même opération peut se
comporter différemment sur différentes classes filles. Le polymorphisme consiste à autoriser le
même code à être utilisé avec différents types, ce qui permet des implémentations plus abstraites et
générales.

4. Classes abstraites

Une classe abstraite est une classe contenant au moins une fonction virtuelle. Une méthode virtuelle
pure est une méthode qui est déclarée dans une classe mais non définie (Pas de corps de cette
méthode). On ne peut pas instancier une classe abstraite et donc on ne peut pas créer d'objet à partir
d'une classe abstraite puisqu’elle a des méthodes non définies. Pour cela, le C++ introduit des
fonctions virtuelles dites "pures" c’est-à-dire qu’on ne donne pas de définition à cette fonction, et
c’est la classe l’héritant qui devra définir cette fonction. Il s’agira alors pour l’utilisateur de la classe
abstraite, de créer une classe la dérivant en créant le code supplémentaire qui définit la fonction
virtuelle.
Prenons l’exemple d’une classe Alpha où est définie la fonction virtuelle affiche qui n’a pas de
corps. Il s’agira alors pour l’utilisateur de la classe Alpha de créer une classe Beta la dérivant en
créant le code supplémentaire qui définit la fonction virtuelle affiche On pourra alors instancier un
objet de type Beta mais on ne peut pas créer d’objet de type Alpha. On est obligé de redéfinir la
fonction affiche ( ) dans la classe fille Beta, sinon cette affiche sera virtuelle pure par héritage et,
par conséquent, la classe Beta sera abstraite elle aussi.
Pour déclarer une fonction virtuelle il suffit d’utiliser le mot clé "virtual" et de faire suivre
également son prototype par "= 0" qui signifie que la méthode n’est pas définie et n’est pas
implémentée dans la classe abstraite. Pour notre fonction affiche, on écrit la fonction affiche dans
la classe de base Alpha comme suit :

virtual void affiche( ) = 0 ;

Dans le fichier "Beta.cpp" de la classe fille Beta, la méthode affiche peut prendre la forme
suivante :

void Beta::affiche( )
{
cout<<"Je suis la methode affiche virtual définie dans Beta"
cout << endl;
}

2
Chapitre 6 Encapsulation et abstraction

5. Surchage d’une fonction

En C++, plusieurs fonctions peuvent avoir le même nom c’est ce qu’on appelle la surchage d’une
fonction. Ces fonctions sont distinctes par leurs signatures (la liste des paramètres). Exemple la
surcharge de la méthode constructeur permet de définir plusieurs constructeurs dans la même
classe. Le compilateur les distingue en considérant le type des paramètres qu’elles reçoivent.
Pour la classe Etudiant avec Nom, Prenom et Matricule comme attributs, on peut avoir les trois
méthodes constructeurs suivantes :
Etudiant (string Nom, int Matricule) ;
Etudiant (string Nom, string prenom) ;
Etudiant (string Nom, string prenom, int Matricule) ;
Elles portent toutes les trois, le même nom (Etudiant), mais le compilateur peut les différencier en
fonction des paramètres.