encapsulation - upjvfurst/docs/4-encapsulation.pdf · programmation objet 1 - encapsulation 11 java...

Programmation Objet 1 - Encapsulation 1

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.

Encapsulation


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

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

Encapsulation et robustesse

class Date{ int jour; int mois; int annee; ...}

class ProgrammeFarceur{ ... void faitFarce(Billet b){ b.d.jour = 32; }}

class Billet{ Date d; ...}

class Tetris{ ... Piece creerNouvellePiece(){ ... }}

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


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


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.

Que faut-il montrer?


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.

Encapsulation des données

objet o1

attributs

méthodes(accesseurs)

objet o2

objet o3

m1

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.

Encapsulation des méthodes

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


Paquetages Java (1/4)

java.io

java

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

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

Annotation AnnotationTypeMismatchException ...

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.

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 :

- donner le nom de la classe in extenso :

- ajouter une directive en tête du fichier :

On peut éviter de préfixer les constantes de classes par le nom de leur classe en utilisantimport static :


import static java.lang.Math.PI;

class Truc{ ... float f = PI*3; ...}

class Truc{ ... p.C variable = ... ...}

import p.C;import java.lang.*;class Truc{ ... C variable = ... ...}


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

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


répertoire monpaquetage

package monpaquetage;

class Truc{ ...}


class Machin{ ...}


…!


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.



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.

Niveau d'encapsulation

modifieur classe paquetage sous-classes

autres classes

private visible

visible visible

protected visible visible visible

public visible visible visible visible


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.

Encapsulation des attributs

class Personne{ private String nom; private Vote v; private int pointure; private float fortune; ... 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; } }


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.

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

Encapsulation et héritage

class Truc{ ... public void m(){ ... }}

class Machin extends Truc{ ... private void m(){ ... }}

Truc t = new Machin();t.m(); ??


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.

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.

Encapsulation et abstraction

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

class Machin extends Truc{ ... protected void m1(){ ... } protected void m2(){ ... } }


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

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

Encapsulation des classes

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


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

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

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

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

Classes internes

class A{ ... class B{ ... }}

public void method(){ class B{ ... } ...}

Objet o = new B(){ ...}


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.

On peut imbriquer des classes sur autant de niveaux que l'on veut.

Classe membre

class MorceauDeGruyere{ ... class TrouDeGruyere{ ... } ...}

class Voiture{ ... class RoueDeVoiture{ ... } ...}

class Feu{ ... class Fumee{ ... class SignauxDeFumee{ ... } }}


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.

L'accès à l'instance de la classe englobante se fait dans la classe membre parNomClasseEnglobante.this (s'il n'y a pas d'ambiguité, le nom du membre dela classe englobante suffit).

Classe membre et encapsulation

class A{

private int z;

public void methode(){...}

... class B{ ... A.this.methode(); z = 12; ... } }


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

}


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

Classe membre et héritage

interface Vide{ public void remplir(Matiere m);}

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

class EspaceCirculaire{ private int rayon; ...}

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


Une interface ou une classe abstraite peuvent être membres d'une classe.

Classe membre et abstraction

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

}


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.

Il est possible d'instancier une classemembre statique sans passer par uneinstance de la classe englobante.

Classe membre de classe

class A{

static class B{ ... }

...

public static void main(String[] t){ B instanceDeB = new B(); }

}


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.

Classe membre et JVM

class A{

class B{ ... }

...

}

A.class

A$B.class

compilation


Une classe locale n'est visible que dans le 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..

Classe locale (1/3)

class A{

public void method(){ class B{ ... } ... }

}


Une classe locale ne peut utiliser une variable locale

que si elle est déclarée final.

Une classe locale ne peut être définie que statiqueou abstraite.

Le compilateur crée pour chaque classe locale un fichier .class numéroté.

Classe locale (2/3)

class A{ public void method(){ final int i = ... int j = ... class B{ int k = i; int l = j; ... } ... }}

class A{ ... void methode(){ class B{ ... } ... class C{ ... } } ...}

A$1$B.class

A$2$C.class

compilation


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.

Classe locale (3/3)

class BuveurDeVin{

public void deboucherBouteille(Bouteille b){ class TireBouchon extends Outil{ ... } TireBouchon tb = new TireBouchon(); tb.debouche(b); ... }

}

class Outil{

...

}


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

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

Classe anonyme (1/2)

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

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


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

Classe anonyme (2/2)

class A{ ... void methode(){ new class B(){ ... } ... } ...}

A$1.classcompilation

encapsulation - upjvfurst/docs/4-encapsulation.pdf · programmation objet 1 - encapsulation 11 java...

Documents