Université Alger1/FS/Dep. MI Enseignant: L.

Djaafri
Module: initiation à la POO

Encapsulation
Définitions
 L'encapsulation est la possibilité pour un objet de cacher ses données (les rendre
protéger).

 L'accès depuis l'extérieur de la classe aux données ne peut se faire qu'à travers ses
méthodes.

 Les données qu'on veut cacher doivent être invisibles depuis l'extérieur (données ou
propriétés privées).

 Les méthodes qui permettent d'accéder aux données doivent être visibles depuis
l'extérieur pour qu'elles soient utilisables dans d'autres classes (méthodes publiques).

Méthodes exposées
(publiques)
Données
cachées
(privées)

Intérêt de l'encapsulation
• L'encapsulation permet l'interdiction d'attribuer des valeurs incohérentes aux
données (valeurs non prévues lors de la conception des classes d'objet).

Les données sont cachées à extérieurs et les seules affectations possibles se feront
par le biais de méthodes (une méthode peut tester les valeurs des attributs).

• L'encapsulation permet aussi de cacher l'implémentation des méthodes ce qui

implique des possibilité d’extension et de maintenance de programmes élevées

Modificateurs de porté pour les classes et membres d'une classe

Un modificateur de porté est un mot clé java qu'on utilise devant le nom d'une classe ou
d'un membre d'une classe pour contrôler l'accès et l'utilisation de cette classe et de ses
membres.

1
Université Alger1/FS/Dep. MI Enseignant: L. Djaafri
Module: initiation à la POO
Valeurs de modificateurs: private, public, [vide] (aucun modificateur)

private public [Rien : aucun midficateur]

Classe Non autorisé
Propriété Attribut accessible
uniquement dans le code
de la classe qui le définit
Méthode Méthodes invoquée
uniquement dans le code
de classe qui le définit.
La classe peut être utilisée
dans n’importe quelle classe
Attribut accessible
directement depuis code de
n’importe quelle classe
Méthodes invoquée dans le
code de n’importe quelle
classe.
La classe ne peut être
utilisée que dans les classes
du même package
Attribut accessible
uniquement dans le code
des classes du même
package.
Méthodes invoquée
uniquement dans le les
méthodes des classes du
même package.

Exemple 1: interdiction d'attribuer des valeurs incohérentes

/*---------------------------------------------------*/
/*---- 2eme implémentation de la classe Personne-----*/
/*---------------------------------------------------*/
class Personne {
String nom;
String prenom;
int age;
/* déclaration des méthodes …*/
}

Class TestPersonne {
public static void main (String args[]){
Personne per1=new Personne(); //utilisation du constructeur par defaut
per1.age=-30; //cette valeur devrait être impossible
}
}

dans cette implémentation de la classe Personne, rien n’empêche de donner la valeur -30 à
l'attribut age de l'objet per1
/*---------------------------------------------------*/
/*---- 2eme implémentation de la classe Personne-----*/
/*---------------------------------------------------*/
class Personne {
private String nom;
private String prenom;
private int age;
/* déclaration des méthodes*/
public void setAge(int age){
if (age>0) this.age=age;
else System.out.println(age +" :est une valeur incorrecte")
}
…
}

class TestPersonne {
Public static void main (String args[]){
Personne per1=new Personne();

2
Université Alger1/FS/Dep. MI Enseignant: L. Djaafri
Module: initiation à la POO
per1.age=-30; /*erreur de compilation; la donnée age est cachée, elle
est déclarée private*/
per1.setAge(-30); /* appel de la méthode publique setAge avec la
valeur -30 passée en argument, mais aucune valeur ne sera affectée à age */
per1.setAge(30); /* appel de la méthode publique setAge avec la valeur
30 passée en argument, la valeur 30 sera affectée à age de l'objet per1 */
}
}

La nouvelle implémentation de la classe personne qui utilise l'encapsulation permet de

restreindre les valeurs de la propriété age et de la rendre cohérente avec sa sémantique.

Exemple 2: assurer une meilleure maintenabilité

Dans l'exemple suivant, on verra comment, on peut modifier la réalisation de la classe Point
sans que cela n'affecte l'utilisation de cette classe dans d'autres classes.

//code utilisant la classe Point

Point p1 = new Point();
p1.translater(x1,y1);
double d = p1.distance();
...

Ce code ne demande aucune maintenance si l'implémentation de la classe point change,

l'essentiel est que les interfaces des méthodes publiques ne changent pas.