Chapitre 3 : Encapsulation et Surcharge
Encapsulation et Surcharge
Objectifs spécifiques :
1. Introduire la notion d’encapsulation et ses intérêts pratiques
2. Assimiler les droits d’accès aux membres de classe { travers la notion de
modificateur de visibilité.
3. Maîtriser la notion de surcharge de méthodes
Eléments de contenu :
- Encapsulation
- Modificateurs de visibilités
-
Surcharge de méthodes
Volume horaire : 1h30
Page | 1
Chapitre 3 : Encapsulation et Surcharge
1. Notion d’Encapsulation
1.1.
Définition :
En plus du regroupement des données et des traitements relatifs à une entité,
l’encapsulation permet de définir deux niveaux de perception :
o Le niveau externe : partie (visible) (par les programmeurs-utilisateurs) de
l’objet : c’est l’interface de l’objet avec l’extérieur résultat du processus
d’abstraction.
o Le niveau interne : (détails d’implémentation de l’objet) : définition de
l’ensemble des méthodes de l’objet : c’est le corps de l’objet
Il y a donc deux facettes à l’encapsulation :
o Regroupement de tout ce qui caractérise l’objet : données (attributs) et
traitements (méthodes)
o
Isolement et dissimulation des détails d’implémentation.
Exemple : L’interface d’une voiture
Accélérer, freiner, embrayer... Tout ce qu’il faut savoir pour la conduire (mais pas la
réparer ! ni comprendre comment ça marche)
L’interface ne change pas, même si l’on change de moteur...
1.2.
Principe de l’encapsulation
Un objet est le regroupement de données (variables ou attributs) et des traitements (méthodes)
associées
L’accès aux données (état) de l’objet ne peut être fait qu’au travers des méthodes.
o Les données sont privées (cachées)
o Les méthodes publiques définissent l’interface de l’objet
L’ensemble des attributs de l’objet ne sont accessibles que via les méthodes de celui-ci
Encapsulation et protection de données
L’ensemble des méthodes définit l’interface { travers laquelle on peut agir sur l’objet (ou
le manipuler).
Page | 2
Chapitre 3 : Encapsulation et Surcharge
1.3.
Intérêts de l’encapsulation
Les avantages de l’encapsulation sont :
-
Simplification de l’utilisation des objets,
- Meilleure robustesse du programme,
-
Simplification de la maintenance globale de l’application
2. Modificateur de visibilité
Les attributs et les méthodes sont précédés lors de la déclaration par l’un des
Publicité
modificateurs de visibilité suivants : « public », « private », « protected » et Néant.
Ils assurent le contrôle des conditions d'héritage, d'accès aux éléments et de
modification de données par les autres objets.
Modificateur
Rôle
Une variable, méthode ou classe déclarée public est visible par tous les autres
public
objets. Dans la philosophie orientée objet aucune donnée d'une classe ne devrait
être déclarée publique : il est préférable d'écrire des méthodes pour la consulter
et la modifier.
Il n'existe pas de mot clé pour définir ce niveau, qui est le niveau par défaut
Friendly
lorsqu'aucun modificateur n'est précisé. Cette déclaration permet à une entité
(Néant)
(classe, méthode ou variable) d'être visible par toutes les classes se trouvant
dans le même package.
Si une méthode ou une variable est déclarée protected, seules les méthodes
protected
présentes dans le même package que cette classe ou ses sous classes pourront y
accéder. On ne peut pas qualifier une classe avec protected.
C'est le niveau de protection le plus fort. Les composants ne sont visibles qu'à
private
l'intérieur de la classe : ils ne peuvent être modifiés que par des méthodes
définies dans la classe prévues à cet effet.
Ces modificateurs d'accès sont mutuellement exclusifs.
Exercice :
Donnez l’accessibilité des attributs A, B, C et D depuis les classes C1, C2, C3 et C4
Page | 3
Chapitre 3 : Encapsulation et Surcharge
Package P1
Package P2
class C1 {
public int A ;
protected int B ;
int C ;
private int D
}
class C2 {
}
Solution :
Accessible par C2
Accessible par C3
Accessible par C4
A
oui
oui
oui
class C3 {
}
class C4 extends C1 {
}
B
oui
non
oui
C
Publicité
oui
non
non
D
non
non
non
3. Accès aux membres privés
L'encapsulation consiste donc à définir la visibilité des attributs et des méthodes afin de
préciser si celles-ci sont accessibles à partir d'autres classes ou non...
Pour accéder aux attributs de l’intérieur de la classe, il suffit d’indiquer le nom de
l’attribut que l’on veut y accéder.
Pour
accéder
de
l’extérieur
de
la
classe,
on
utilise
la
syntaxe
<nom_Objet>.<nom_attribut> sauf si l’attribut en question a été déclaré private
Ainsi, pour pouvoir manipuler des données déclarées private, le programmeur de la
classe doit prévoir ce que l’on appelle des accesseurs (getters) et des modificateurs
(setters).
Un accesseur est une méthode permettant de récupérer le contenu d'une donnée
membre protégé par un modificateur de visibilité « private ». Le nom d’un getter
commence toujours par get, suivi du nom de l’attribut.
Page | 4
Chapitre 3 : Encapsulation et Surcharge
Pour accomplir sa fonction, un accesseur :
- doit avoir comme type de retour le type de la variable à renvoyer
- ne doit pas posséder d'arguments
Un modificateur est une méthode permettant de modifier le contenu d'une donnée
membre protégé par un modificateur de visibilité « private ». Le nom d’un setter
commence toujours par set, suivi du nom de l’attribut.
Pour accomplir sa fonction, un setter :
- doit avoir comme paramètre la valeur à assigner à la donnée membre. Le
paramètre doit donc être du type de la donnée membre
- ne doit pas nécessairement renvoyer de valeur (il possède dans sa plus simple
expression le type void)
Exemple : Reprenons l’exemple de la classe Rectangle
- Si longueur et largeur étaient des attributs public de Rectangle, on peut écrire le code
suivant dans la méthode « main » de la classe Test_Rect
Rectangle r = new Rectangle ();
r.longueur = 20;
r.largeur = 15;
int la = r.longueur ;
-
Si longueur et largeur étaient des attributs privés « private », les instructions
précédentes seront refusées par le compilateur. Il faut donc, dans ce cas définir des
accesseurs (getters) et des modificateurs (setters) pour pouvoir y accéder.
public class Rectangle {
private int longueur;
Publicité
private int larg;
//Le premier constructeur
Rectangle (int l, int a) {
longueur= l;
larg= a;
}
// Le deuxième constructeur
Rectangle() {
longueur= 20;
larg= 10;}
//Le troisième constructeur
Rectangle (int x) {
longueur= 2*x;
larg= x;}
//pour retourner la valeur de longueur
int getlong () {
return (longueur);
}
Page | 5
Chapitre 3 : Encapsulation et Surcharge
//Pour retourner la largeur
int getlarg () {
return (larg);
}
//pour modifier la longueur
void setlong (int l) {
longueur=l;
}
//pour modifier la largeur
void setlarg (int l) {
larg=l;
}
//Pour calculer la surface
int surface(){
return(longueur*larg);
}
//pour calculer le périmètre
int périmètre()
{
return((larg+longueur)*2);}
//Pour allonger la longueur d’un rectangle
void allonger(int l)
{
longueur+=l;
}
//pour afficher les caractéristiques d’un rectangle
void affiche()
{
System.out.println("Longueur=" + longueur + " Largeur =" + larg );
}
}
Code de la classe Test_Rect
public class Rest_Rect {
public static void main(String[] args) {
Rectangle r = new Rectangle(10,5);
Rectangle r3;
r3= new Rectangle (14);
Publicité
Rectangle r2 = new Rectangle();
r.affiche();
r2.affiche();
r3.affiche() ;
r2.setlong(50);
r2.setlarg(30);
r2.affiche();
System.out.println("Rectangle1" );
System.out.println("Surface= " + r.surface());
System.out.println("Périmetre= " + r.périmètre());
r.allonger(40);
System.out.println("Aprés allongement");
r.affiche();
}
}
Page | 6
4. Surcharge
Chapitre 3 : Encapsulation et Surcharge
La surcharge de méthode est la possibilité d'appeler plusieurs méthodes avec le même
nom, à condition que leurs arguments diffèrent (en type et/ou en nombre).
Elle permet de donner le même nom à des méthodes comportant des paramètres
différents et simplifie donc l'écriture de méthodes sémantiquement similaires sur des
paramètres de type différent. Elle constitue un des apports les plus intéressants du
langage Java.
Il est ainsi possible de définir une méthode réalisant la même opération sur des variables
différentes en nombre ou en type.
La surcharge peut concerner une méthode locale ou héritée.
Nous avons déjà utilisé la surcharge lors de la définition de constructeurs d'objets et
avons vu à cette occasion que la sélection par le compilateur de la méthode à invoquer
est réalisée sur la base de la liste et du type de ses différents paramètres. Ce que nous
avons fait pour les constructeurs peut l'être pour toute méthode d'une classe.
Exemple
La classe Rectangle peut avoir plusieurs méthodes Allonger () acceptant des paramètres
différents en nombre et/ou en types.
//Pour allonger la longueur d’un rectangle
void allonger(int l) //Pour allonger la longueur d’un rectangle
{
longueur+=l;
}
//Pour allonger un rectangle
void allonger(int l, int k)
{
longueur+=l;
larg+= k;
}
Lors de l’appel des méthodes surchargées, le compilateur sait distinguer entre les méthodes en
considérant le nombre et les types des paramètres
Rectangle r = new Rectangle (5,10) ; //Appel de constructeur à 2 paramètres
r.allonger (10) ; // Appel de la 1ère méthode surchargée
r.allonger (10, 3) ; // Appel de la 2ème méthode surchargée
Page | 7