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.

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

class Date{ class ProgrammeFarceur{

// attributs class BilleterieSNCF{
...
int jour; // attributs
void faitFarce(BilleterieSNCF b){
int mois; Date d;
b.d.jour = 32;
int annee; ...
}
... }
}
}

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

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

2
 class PileDeChaines{
// attributs
String[] pile;
// méthodes
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{
// attributs
ArrayList<String> pile;
// méthodes
...
}

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.

4
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

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(){
...
this.coupe(...);
...
}
...
}

6
 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

java.lang java.io java.nio java.math java.net java.text java.util java.sql ...

java.lang.annotation java.lang.instrument java.lang.reflect ...

Annotation AnnotationTypeMismatchException ...

Les noms des paquetages suivent la convention inverse des URI internet:
com.monlogiciel.paquetage2

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 java.lang.*;
class Truc{
- ajouter une directive en tête du fichier : ...
C variable = ...
...
}

import static java.lang.Math.PI;

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

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

8
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/Truc.java

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

peuvent contenir des classes de même nom.

Exemple: les 3 interfaces javax.lang.model.element.Name, javax.naming.Name et

javax.xml.soap.Name sont différentes.

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

applications.

Exemples: java.applet contient les classes dédiées à la réalisation d'applications

clientes pour pages web, java.security regroupe les classes dédiées à la gestion de la
sécurité.

Les paquetages permettent de moduler l'encapsulation.

10
Les 4 niveaux d'encapsulation de Java sont par ordre de visibilité croissante :
– un membre privé (private) n'est visible que dans les instances
directes de la classe où il est déclaré.
– un membre sans modifieur est visible uniquement dans les instances
directes de la classe où il est déclaré et dans celles des classes du
même paquetage.
– un membre protégé (protected) n'est visible que dans les instances,
directes ou non, de la classe où il est déclaré (et donc aussi dans les
instances des sous-classes) et dans les instances des classes du
même paquetage.
– un membre public (public) est visible par n'importe quel objet.

Ces 3 modifieurs se retrouvent en C++, Python, etc.

11

Visibilité des membres selon leurs modifieurs et le niveau d'encapsulation

modifieur classe paquetage sous- autres

classes classes
private visible
visible visible
protected visible visible visible
public visible visible visible visible

12
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{
// attributs
private String nom;
private Vote v;
private int pointure;
private float fortune;
...
// methodes
public String getNom(){
return this.nom;
}
public int getPointure(){
return this.pointure;
}
public void donnerSous(float s){
this.fortune = this.fortune.s;
}
public float getFortune(Object o){
if(o instanceof Etat) return this.fortune;
}
}
13

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.

14
 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.

15

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); package monPaquetage;
public Object enleverElement(Object o);
public boolean estVide(); class ImplémentationDeListe extends Liste{
public Liste creerListe(){ ...
return new ImplementationDeListe(); }
}
...
}

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

16
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 class B{
...
les attributs et méthodes de la classe englobante. }
}

public void method(){

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

Une classe anonyme est définie à l'intérieur d'une Objet o = new B(){
...
expression. }

17

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. ...
}
}
}

18
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 public void methode(){...}

englobante se fait dans la classe membre
...
par NomClasseEnglobante.this (s'il
n'y a pas d'ambiguité, le nom du membre class B{
...
de la classe englobante suffit). A.this.methode();
z = 12;
...
}

19

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 = instanceDeA.new B();
A.B autreB = new B();
A.B.C unC = instanceDeB.new C();
}
}

20
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{
...
}
...
}

21

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)) this.fp = new CSVParser();
if(isODS(name)) this.fp = new ODSParser();
...
}
}

22
Si la classe membre est déclarée statique, 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 public static void main(String[] t){
classe englobante. }
B instanceDeB = new B();

23

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.

A.class
class A{
class B{
... compilation
}
... A$B.class

24
 class A{
public void method(){
Une classe locale n'est visible que dans le class B{
...
bloc de code où elle est définie (elle est }
forcément «privée»). ...
}
}

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.

25

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

class A{
... A$1$B.class
void methode(){
class B{
Le compilateur crée pour ...
chaque classe locale un } compilation
...
fichier .class numéroté. class C{ A$2$C.class
...
}
}
...
}

26
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();
tb.debouche(b);
...
}
}

27

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 ...
bouton.addActionListener(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).

28
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.

class A{
...
void methode(){
Le compilateur génère new class B(){
... A$1.class
pour chaque classe } compilation
...
anonyme un fichier }
...
.class numéroté. }

29