Encapsulation

L'encapsulation consiste à rendre les membres d'un objet plus ou moins visibles pour
les autres objets.

La visibilité dépend des membres : certains membres peuvent être visibles et d'autres
non.

La visibilité dépend de l'observateur : les membres de l'objet encapsulé peuvent être

visibles pour certains objets mais pas pour d'autres.

L'encapsulation a pour objectif d'améliorer la robustesse et l'évolutivité des

programmes.

Programmation Objet 1 - Encapsulation 1

 Encapsulation et robustesse

Les objets doivent pouvoir protéger les données qu'ils contiennent.

class Date{ class ProgrammeFarceur{

int jour; class Billet{ ...
int mois; Date d; void faitFarce(Billet b){
int annee; ... [Link] = 32;
... } }
} }

Les objets doivent pouvoir protéger les méthodes qu'ils contiennent.

class ProgrammeEtourdi{
class Tetris{ ...
... void faitErreur(Tetris t){
Piece creerNouvellePiece(){ Tetris t = ...
... [Link]();
} [Link]();
} }
}

Programmation Objet 1 - Encapsulation 2

 Encapsultation et évolutivité

class PileDeChaines{
String[] pile;
void push(String s){
// ajouter s à la fin de pile
}
String top(){
// renvoyer le dernier élément de pile
}
String pop(){
// enlever le dernier élément de pile et le renvoyer
}
boolean estVide(){
// renvoyer vrai si la taille de pile est 0, faux sinon
}
}

class PileDeChaines{
ArrayList<String> pile;
...
}

Programmation Objet 1 - Encapsulation 3

 Que faut-il montrer?

Principe de David Parnas :

Une classe doit rendre visible ce qui est nécessaire pour

manipuler ses instances et rien d'autre.

L'implémentation d'une méthode doit utiliser ce qui est

nécessaire au traitement qu'elle réalise et rien d'autre.

Programmation Objet 1 - Encapsulation 4

 Encapsulation des données

Par défaut, les attributs doivent être cachés. Leurs valeurs ne doivent être visibles et
modifiables qu'au travers des méthodes. Il est cependant acceptable de laisser visible
les constantes.

objet o1
méthodes
objet o2
(accesseurs)

m1
attributs objet o3

m2

Programmation Objet 1 - Encapsulation 5

 Encapsulation des méthodes

Les méthodes intermédiaires qui ne sont pas destinées à être utilisées à l'extérieur de
la classe doivent être cachées.

class ListeDeTruc{
...
// méthodes
void coupe(Truc pivot){
...
}

void trier(){
...
[Link](...);
...
}
...
}

Programmation Objet 1 - Encapsulation 6

 Paquetages Java (1/4)

En Java, il existe deux périmètres de visibilité : les classes et les paquetages.

Un paquetage est un regroupement de classes. Les paquetages sont organisés

hiérarchiquement comme des répertoires de classes.
java

[Link] [Link] [Link] [Link] [Link] [Link] [Link] ...

[Link] [Link] [Link] ...

Annotation AnnotationTypeMismatchException ...

Les noms des paquetages suivent la convention inverse des URI internet :
[Link].paquetage2

Programmation Objet 1 - Encapsulation 7

 Paquetages Java (2/4)

Pour utiliser dans un fichier java une classe C d'un paquetage p, on peut :

class Truc{
- donner le nom de la classe in extenso : ...
p.C variable = ...
...
}

import p.C;
import [Link].*;
- ajouter une directive en tête du fichier : class Truc{
...
C variable = ...
...
}

import static [Link];

On peut éviter de préfixer les constantes de class Truc{

classes par le nom de leur classe en utilisant ...
import static : float f = PI*3;
...
}

Programmation Objet 1 - Encapsulation 8

 Paquetages Java (3/4)

Pour organiser ses propres classes en paquetage :

- placer les classes dans un répertoire portant le nom souhaité

- mettre en tête de fichier la directive package correspondante

répertoire monpaquetage

package monpaquetage; package monpaquetage; package monpaquetage;

class Truc{ class Machin{ …!

... ...
} }

La compilation et l'exécution de ces classes doit se faire en précisant le chemin qui y

mène : javac -classpath …/monpaquetage/[Link]

Programmation Objet 1 - Encapsulation 9

 Paquetages Java (4/4)

Les paquetages représentent des espaces de nommage : deux paquetages peuvent

contenir des classes de même nom.

Exemple : les 3 interfaces [Link], [Link].

Name et [Link] sont différentes.

Les paquetages permettent d'organisation les classes par thèmes, par applications.

Exemples : [Link] contient les classes dédiées à la réalisation d'applications

clientes pour pages Web, [Link] regroupe les classes dédiées à la gestion
de la sécurité.

Les paquetages permettent de moduler l'encapsulation.

Programmation Objet 1 - Encapsulation 10

 Niveau d'encapsulation

Java (et C++, Pyhton, …) offre 3 modifieurs de visibilité : private, protected et

public.

Ces modifieurs (ou l'absence de modifieur) permettent de moduler la visibilité d'un

membre d'une classe selon que l'on se place dans la même classe, dans une sous-
classe, dans une classe du même paquetage, ou ailleurs.

modifieur classe paquetage sous- autres

classes classes
private visible
visible visible
protected visible visible visible

public visible visible visible visible

Programmation Objet 1 - Encapsulation 11

 Encapsulation des attributs

Les attributs doivent a priori être privés (ou au moins protégés). Si besoin, des
accesseurs et modifieurs publics sont définis et permettent de contrôler l'accès aux
attributs.

class Personne{
private String nom;
private Vote v;
private int pointure;
private float fortune;
...
public String getNom(){
return [Link];
}
public int getPointure(){
return [Link];
}
public void donnerSous(float s){
[Link] = [Link].s;
}
public float getFortune(Object o){
if(o instanceof Etat) return [Link];
}
}

Programmation Objet 1 - Encapsulation 12

 Encapsulation et héritage

La redéfinition d'une méthode doit avoir une visibilité au moins égale à celle de la
méthode de la super-classe. Cette contrainte est due à la liaison dynamique.

class Truc{ class Machin extends Truc{

... ...
public void m(){ private void m(){
... ...
} }
} }

Truc t = new Machin();

t.m(); ??

Le masquage d'un attribut, géré par liaison statique, ne pose aucune contrainte sur
l'encapsulation.

Programmation Objet 1 - Encapsulation 13

 Encapsulation et abstraction

Une méthode abstraite ne peut être privée car elle doit être implémentée dans une
sous-classe. Elle peut être implémentée par une méthode ayant une visibilité plus
large qu'elle-même.

class Machin extends Truc{

abstract class Truc{ ...
... protected void m1(){
abstract void m1(); ...
protected abstract void m2(); }
... protected void m2(){
} ...
}
}

Une interface ne contient que des membres publics ou sans modifieur de visibilité.

Les membres de classe se comportent comme les membres d'instances du point de

vue de l'encapsulation.

Programmation Objet 1 - Encapsulation 14

 Encapsulation des classes

Une classe (ou interface) déclarée public est visible de partout, sinon elle n'est
visible que dans son paquetage.

package monPaquetage;

public abstract class Liste{

public void ajoutElement(Object o);
public Object enleverElement(Object o);
public boolean estVide();
public Liste creerListe(){
return new ImplementationDeListe();
}
...
}
package monPaquetage;

class ImplémentationDeListe extends Liste{

...
}

Les classes qui ne sont pas déclarées dans un paquetage font toutes partie du même
paquetage « anonyme ».

Programmation Objet 1 - Encapsulation 15

 Classes internes

Une classe interne est une classe définie à l'intérieur d'une autre classe.

class A{
Une classe membre est définie au même niveau que ...
les attributs et méthodes de la classe englobante.
class B{
...
}
}

public void method(){

Une classe locale est définie à l'intérieur d'une méthode.
class B{
...
}
...
}

Objet o = new B(){

Une classe anonyme est définie à l'intérieur d'une ...
expression.
}

Programmation Objet 1 - Encapsulation 16

 Classe membre

Toute instance d'une classe membre est associée à une instance de la classe
englobante.

Une classe membre n'a donc de sens que si ses instances ne peuvent exister que
comme parties d'instances de la classe englobante.

class MorceauDeGruyere{ class Voiture{

... ...
class TrouDeGruyere{ class RoueDeVoiture{
... ...
} }
... ...
} }

class Feu{
...
class Fumee{
...
On peut imbriquer des classes sur autant de class SignauxDeFumee{
niveaux que l'on veut. ...
}
}
}
Programmation Objet 1 - Encapsulation 17
 Classe membre et encapsulation

Une classe membre a accès aux attributs et méthodes de la classe englobante,

même s'ils sont privés.

Une classe englobante à accès à tous les membres de sa classe interne même ceux
qui sont privés.

class A{

private int z;
L'accès à l'instance de la classe englobante
se fait dans la classe membre par public void methode(){...}
[Link] (s'il n'y
a pas d'ambiguité, le nom du membre de ...
la classe englobante suffit).
class B{
...
[Link]();
z = 12;
...
}

Programmation Objet 1 - Encapsulation 18

 Instanciation d'une classe membre

L’instanciation de la classe membre se fait à travers une instance de la classe

englobante.

class A{

class B{

class C{
...
}

...

...

public static void main(String[] t){

A instanceDeA = new A();
B instanceDeB = [Link] B();
A.B autreB = new B();
A.B.C unC = [Link] C();
}

Programmation Objet 1 - Encapsulation 19

 Classe membre et héritage

L'héritage est totalement indépendant de l'imbrication de classe.

class MorceauDeGruyere extends Aliment{

...
class TrouDeGruyere extends EspaceCirculaire implements Vide{
...
}
...
}

interface Vide{ class EspaceCirculaire{

public void remplir(Matiere m); private int rayon;
} ...
}

class Humain{
...
class Foetus extends Humain{
...
}
...
}

Programmation Objet 1 - Encapsulation 20

 Classe membre et abstraction
Une interface ou une classe abstraite peuvent être membres d'une classe.

class File {

interface FileParser {
boolean parse();
}

class CSVParser implements FileParser {

public void parse() {...}
}

class ODSParser implements FileParser {

public void parse() {...}
}

private FileParser fp;

public File(String name){

...
if(isCSV(name)) [Link] = new CSVParser();
if(isODS(name)) [Link] = new ODSParser();
...
}

}
Programmation Objet 1 - Encapsulation 21
 Classe membre de classe

Si la classe membre est déclarée static, elle n'est pas liée à une instance de la
classe englobante.

Le mot clé this ne peut y être employé, donc la classe membre de classe n'a pas
accès aux attributs et méthodes non statiques de la classe englobante.

Une classe statique a accès à tous les membres statiques de la classe englobante.

class A{

static class B{
Il est possible d'instancier une classe ...
membre statique sans passer par une }
instance de la classe englobante.
...

public static void main(String[] t){

B instanceDeB = new B();
}

Programmation Objet 1 - Encapsulation 22

 Classe membre et JVM

Le compilateur insère automatiquement dans la classe membre un attribut privé qui

référence l'instance englobante.

Le compilateur ajoute automatiquement à tous les constructeurs de la classe membre

un argument caché qui pointe sur la classe englobante. Il ajoute aussi des accesseurs
vers les membres privés dans les deux classes.

La JVM gère les classes membres comme des classes normales.

class A{ [Link]

class B{
... compilation
}
A$[Link]
...

Programmation Objet 1 - Encapsulation 23

 Classe locale (1/3)

Une classe locale n'est visible que dans le bloc de code où elle est définie (elle est
forcément « privée »)

class A{

public void method(){

class B{
...
}
...
}

Une classe locale définie dans une méthode d'instance a accès aux attributs et
méthodes de la classe englobante, même s'ils sont privés.

Une méthode locale définie dans une méthode de classe n'a accès qu'aux membres
de classes de la classe englobante..

Programmation Objet 1 - Encapsulation 24

 Classe locale (2/3)

Une classe locale ne peut utiliser une variable locale class A{

public void method(){
que si elle est déclarée final. final int i = ...
int j = ...
class B{
int k = i;
int l = j;
...
Une classe locale ne peut être définie que statique }
ou abstraite. ...
}
}

class A{
...
Le compilateur crée pour
void methode(){ A$1$[Link]
chaque classe locale un class B{
fichier .class numéroté. ...
} compilation
...
class C{ A$2$[Link]
...
}
}
...
}
Programmation Objet 1 - Encapsulation 25
 Classe locale (3/3)

Une classe locale ne sert pas vraiment à modéliser des données, mais constitue une
technique permettant de définir localement un type.

Le plus souvent, on utilise une classe locale pour spécialiser une classe existante et
réutiliser ainsi du code localement.

class Outil{

...

class BuveurDeVin{

public void deboucherBouteille(Bouteille b){

class TireBouchon extends Outil{
...
}
TireBouchon tb = new TireBouchon();
[Link](b);
...
}

}
Programmation Objet 1 - Encapsulation 26
 Classe anonyme (1/2)

Une classe anonyme est une classe locale sans nom, définie dans une instruction et
instanciée dans la foulée.

interface ActionListener{
public void actionPerformed(ActionEvent ae);
}

class InterfaceGraphique{
public InterfaceGraphique(){
...
Button bouton ...
[Link](new ActionListener(){
public void actionPerformed(ActionEvent ae){
...
}
};
...
}
...
}

Une classe anonyme ne peut être réutilisée, ne peut avoir qu'une seule instance et n'a
pas de constructeur (l'instance unique est créée avec le constructeur par défaut).

Programmation Objet 1 - Encapsulation 27

 Classe anonyme (2/2)

Une classe anonyme n'autorise aucun modifieur et est toujours final

(implicitement).

Une classe anonyme subit les mêmes restrictions d'accès aux membres de la classe
englobante qu'une classe locale.

Le compilateur génère pour chaque classe anonyme un fichier .class numéroté.

class A{
...
void methode(){
new class B(){ A$[Link]
... compilation
}
...
}
...
}

Programmation Objet 1 - Encapsulation 28