3

CHAPITRE III

L’encapsulation, la surcharge et
l’agrégation

I. Le paquetage
Un package peut être considéré comme une bibliothèque de classes : il permet de regrouper
un certain nombre de classes relativement liées. Les packages peuvent être organisés d’une
manière hiérarchique en sous packages.

java

util lang io awt

Event
String Input Stream Component
Date
System FileInputStream Container
Vector
Thread StringBufferInputStream Evénements
Enumeration
Object outputStream ……….
Random
……….. FileOutputStream
StringTokenizer
………
Cours : Programmation Orientée Objet Chapitre3 : L’encapsulation, la surcharge et l’agrégation

Avantages

- Facilite le développement des bibliothèques et des modules autonomes.

- Les classes d’un même package concernent un même domaine.
- Facilite la réutilisabilité.
Organisation

- Les classes publiques doivent être enregistrées physiquement dans des fichiers qui
portent leurs noms et se trouvent dans un répertoire qui porte le même nom du
package.
- Ainsi les classes du package java.lang se trouvent dans un sous répertoire
java/lang accessible par la variable d’environnement CLASSPATH.
Utilisation d’un package
On peut utiliser une classe d’un package à travers 2 méthodes :
- Soit en indiquant la hiérarchie des packages puis le nom de la classe. Le tout est
séparé par des points.
Exemple : pour accéder à la classe Date de package « util », on écrit java.util.Date
- Soit en important le package ou la classe concernée
Exemple : import java.util.Date ; //pour importer la classe Date
Ou java.util.* //pour importer toutes les classes de package java.
Affectation d’une classe à un package
1. Ajouter au début de la classe la ligne suivante :
package <nom_du_package>;
2. Enregistrer le fichier dans un répertoire portant le même nom et/ou chemin de package.
3. Ajouter le chemin de package dans la variable CLASSPATH.
Exemple : Si on veut créer une classe publique Rectangle appartenant au package « forme »
qui lui aussi appartient au package « graphiques », on doit procéder la classe par l’instruction
package graphiques.forme ;
public class Rectangle
{…..}
- Cette classe doit être enregistrée dans un sous répertoire graphiques\forme et dans un fichier
qui s’appelle « Rectangle.java »

Enseignante : Afifa Khélifa Zguerni Page 15

Cours : Programmation Orientée Objet Chapitre3 : L’encapsulation, la surcharge et l’agrégation

II. L’encapsulation
L’encapsulation est la possibilité de ne montrer de l’objet que ce qui est nécessaire à son
utilisation.
L’encapsulation permet d’offrir aux utilisateurs d’une classe la liste des méthodes et
éventuellement des attributs utilisables depuis l’extérieur. Cette liste de services exportables
est appelée l’interface de la classe et elle est composée d’un ensemble des méthodes et
d’attributs dits publics (public).
Les méthodes et attributs réservés à l’implémentation des comportements internes à l’objet
sont dits privés (private). Leur utilisation est exclusivement réservée aux méthodes définies
dans la classe courante.
Les avantages de l’encapsulation sont :
- Simplification de l’utilisation des objets,
- Meilleure robustesse du programme,
- Simplification de la maintenance globale de l’application

1. Modificateurs de visibilité
Les attributs et les méthodes sont précédés lors de la déclaration par l’un des modificateurs de
visibilité suivants : « public », « private », « protected » et Néant.
- Une méthode, classe ou attribut sont déclarés comme publiques « public » s’ils doivent être
visibles à l’intérieur et à l’extérieur quelque soit leur package.
- Une méthode, classe ou attribut ne sont pas précédés par un modificateur de visibilité explicite
(Néant) ne vont être visibles qu’à l’intérieur de même package. C'est-à-dire seules les classes
de même package peuvent accéder aux attributs et méthodes de classes « amies ». Ce
modificateur de visibilité est aussi appelé « modificateur de package » ou modificateur
« freindly ».
- Une méthode ou attribut définis comme étant privés « private » s’ils sont accessibles
uniquement par les méthodes de la classe en cours. Ils ne sont pas accessibles ailleurs.
- Une méthode ou attribut sont définis comme protégés « protected » s’ils ne peuvent être
accessibles qu’à travers les classes dérivées ou les classes de même package.

Enseignante : Afifa Khélifa Zguerni Page 16

Cours : Programmation Orientée Objet Chapitre3 : L’encapsulation, la surcharge et l’agrégation

2. Tableaux récapitulatifs des droits d’accès

Modificateurs d’accès des classes et interfaces

Modificateur Signification pour une classe ou une interface

public Accès toujours possible

Néant Accès possible depuis les classes du même paquetage

Modificateurs d’accès pour les membres

Modificateur Signification pour les membres (attributs et méthodes)

public Accès possible partout où la classe est accessible

Néant Accès possible depuis toutes les classes du même paquetage

protected Accès possible depuis toutes les classes du même paquetage ou depuis
les classes dérivées
private Accès restreint à la classe où la déclaration est faite

3. Accès aux attributs via les méthodes accesseurs

- 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 ou bien en utilisant le mot clé this.
- Pour accéder de l’extérieur de la classe, l’accès est conditionné par le droit d’accès (le
modificateur de visibilité utilisé).
o Dans le cas favorable : le modificateur de visibilité permet l’accès, on utilise la
syntaxe suivante : <nomObjet>.<nom_attribut>
o Sinon, l’accès direct aux attributs est impossible, on doit alors penser à utiliser
les méthodes accesseurs si elles existent. Ces méthodes accesseurs permettent
l’accès aux attributs privés en lecture ou en écriture tout en protégeant
l’attribut contre les utilisations incorrectes.
- Conventionnellement, les méthodes d’accès en lecture commencent par « get » et les
méthodes d’accès en écriture commencent par « set »
Exemple
* Si seconde, minute et heure de la classe Horloge sont déclarés comme attributs publics, on
peut écrire le code suivant dans la méthode « main » de la classe TestHorloge

Enseignante : Afifa Khélifa Zguerni Page 17

Cours : Programmation Orientée Objet Chapitre3 : L’encapsulation, la surcharge et l’agrégation

Horloge h1 = new Horloge ();

h1.seconde = 70;
h1.heure = 15;
int m = h1.minute ;
* Si seconde, minute et heure sont déclarés des attributs privés, les instructions précédentes
seront refusées par le compilateur. Il fallait dans le deuxième cas définir des méthodes
d’accés setMinute (int), setSeconde (int), setHeure (int) qui permettent de modifier les
valeurs des attributs et les méthodes d’accès getMinute (), getSeconde() et getHeure() pour
retourner les valeurs de minute, seconde et heure d’un objet Horloge. Dans ce cas, les
instructions seront les suivantes :
Horloge h1 = new Horloge ();
h1.setSeconde (70);
h1.setHeure(15);
int m = h1.getMinute() ;
Exemple Complet

public class Horloge

{
private int heure, minute, seconde;
public Horloge ()
{seconde = 0; Minute=0 ; heure =12;}
public int getSeconde () //pour retourner les secondes
{return (seconde);}
public int getMinute () //Pour retourner les minutes
{return (minute);}
public int getHeure () //Pour retourner les heures
{return (heure);}
void setHeure (int h) //pour modifier les heures
{if (h>=0 && h<=23) heure=h;}
void setMinute (int m) //pour modifier les minutes
{if (m>=0 && m<=59) minute=m; }
void setSeconde (int s) //pour modifier les secondes
{if (s>=0 && s<=59) seconde=s; }
}
La classe Test_Horloge
public class Test_Horloge{
public static void main(String [] args)
{
Horloge h1 = new Horloge ();
h1.setMinute (30);
h1.setSeconde (25);
h1.setHeure (40);
System.out.println (h1.getHeure () + “:” + h1.getMiute ()
+ “:” +h1.getSeconde ());
}}

Enseignante : Afifa Khélifa Zguerni Page 18

Cours : Programmation Orientée Objet Chapitre3 : L’encapsulation, la surcharge et l’agrégation

L’exécution de la classe TestHorloge nous affiche le résultat suivant: 12 : 30 : 25

III. Surcharge des Méthodes

- La surcharge est la capacité des objets d’une même hiérarchie de classes à répondre
différemment à une méthode de même nom, mais avec des paramètres différents.
Par exemple, la classe Point peut avoir deux méthodes Translation acceptant des
paramètres différents en nombre et/ou en types.
- En fonction du type et de nombre de paramètres lors de l’appel, la méthode
correspondante sera choisie.
- Le mécanisme de surcharge permet de réutiliser le nom d’une méthode déjà définie,
pour une autre méthode qui en différera par ses paramètres.
- La méthode surchargée doit conserver la même “intention sémantique”
- La surcharge peut se faire sur une méthode définie localement ou héritée.
Exemple
public class Point
{
private int abs, ord ;
private char nom;
public Point ()
{nom=’O’ ; abs=0 ; ord=0 ;}
public Point (char n, int a, int b //surcharge du constructeur
{nom=n ; abs=a ; ord=b ;}
public void Translation (int l1, int l2)
//Pour translater un point
{
abs+=l1;
ord+=l2 ;
}
public void Translation (int v) //surcharge de Translation
//Pour translater un point
{
abs+=v;
ord+=v ;
}
}
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
Point p1 = new Point (‘A’, 5,10) ;
//Appel de constructeur à 3 paramètres
Point p2 = new Point () ;

Enseignante : Afifa Khélifa Zguerni Page 19

Cours : Programmation Orientée Objet Chapitre3 : L’encapsulation, la surcharge et l’agrégation

//Appel de constructeur sans paramètres

p1.Translation (10) ;
// Appel de la 1ère méthode surchargée Translation
p2.Translation (2, 3) ;
// Appel de la 2ème méthode surchargée Translation

IV. L’agrégation/Composition
L’agrégation est une forme particulière d’association non symétrique qui exprime l’idée
qu’un objet « fait partie » d’un autre objet.
Sa sémantique détermine généralement un lien fort entre les classes concernées. L’une des
classes est composée d’instances issues de l’autre classe et joue donc un rôle de conteneur.
On distingue également la composition de l’agrégation.
 Une agrégation est dite partageable : elle permet de regrouper des éléments
indépendants mais ceux-ci peuvent appartenir également à d’autres agrégats.
 Une composition permet de traduire l’aspect composite d’un objet. Chaque composant
correspond à une partie intégrante du tout et ne peut donc pas être partagée.
La composition est parfois qualifiée d’agrégation par valeur, par opposition à l’agrégation par
référence, ou agrégation partagée.
Pour se rapporter à des opérateurs ensemblistes, on peut considérer que le lien d’agrégation
détermine une appartenance et que le lien de composition correspond à une inclusion. En
UML, on représente une agrégation par un losange vide et une composition par un losange
plein.
Exemples d’agrégation

- La relation entre un email et les destinataires.

- La relation entre un segment et ses extrémités (de type point).
- La relation entre commande et produits
- La relation entre bibliothèque et document.
- La relation entre texte et caractère.
- La relation entre équipe et joueur.
Exemples de composition

- La relation entre horloge et compteur cyclique.

- La relation entre véhicule et moteur.
Remarques
- Le cycle de vie de l’agrégat est ses composés peuvent être indépendants.
- Les cycles de vie des éléments (les "composants") et du composé coïncident : si le
composé est détruit (ou copié), ses composants le sont aussi.

Enseignante : Afifa Khélifa Zguerni Page 20

Cours : Programmation Orientée Objet Chapitre3 : L’encapsulation, la surcharge et l’agrégation

- Dans le cas de l’agrégation : l’instanciation des objets composites se fait à l’extérieur

de la classe de l’agrégat.
- Dans le cas de la composition, l’instanciation des objets composants se fait à
l’intérieur de la classe qui constitue le composé.

Exemple 1 (Agrégation)

Point
Segment
- Nom : char
- Abs : int
- Ord : int
+ Point (char, int, int) *
+ Segment (Point, Point)
+ toString () : String + toString () : String
2
+ Translation (int, int) + Longueur () : double
+ Distance (Point) : double +Appartenir (Point) : boolean
public class Point
{
private int Abs, Ord ;
private char Nom;
public Point (char N, int a, int b)
{Abs=a; Ord= b; Nom=N;}
public String toString ()
{return (Nom + "(" + Abs + "," + Ord + ")");}
public void Translation (int a, int b)
{Abs+=a; Ord+=b;}
public double Distance (Point p)
{return(java.lang.Math.sqrt((Abs-p.Abs)*(Abs-p.Abs)+(Ord-p.Ord)*(Ord-p.Ord)));}
}

public class Segment

{ private Point Ext1, Ext2;
public Segment (Point E1,Point E2)
{Ext1=E1; Ext2=E2;}
public String toString ()
{return ("[" + Ext1.toString () + " " + Ext2.toString () + "]");}
public double Longueur ()
{return (Ext1.Distance (Ext2));}
public boolean Appartient (Point p)
{return((Ext1.Distance(p)+ Ext2.Distance(p))==Ext1.Distance (Ext2));}

}
public class Test {
public static void main (String [] argv) {
Point p1, p2, p3; Segment s1;
p1=new Point ('A', 2,3); p2=new Point ('B', 1, 4);
s1=new Segment (p1, p2);
System.out.println("Long de" + s1.toString() + "= "+ s1.Longueur()) ;
p3= p1 ;
if (s1.Appartient(p3)==true)
System.out.println (p3 + " appartient au " + s1);
else
System.out.println (p3 + "n’appartient pas au segment" + s1);
}
}

Enseignante : Afifa Khélifa Zguerni Page 21

Cours : Programmation Orientée Objet Chapitre3 : L’encapsulation, la surcharge et l’agrégation

Exemple 2 (Composition)

Ordinateur

- NumSerie : String
- Marque : String
- Processeur : String
- Memoire : String
- Prix : double
+ Ordinateur (String, String, String, String, double, int, String)
+ AjouterDisque (int, String)
+ AjouterPeripherique (String, String, String)
+ ChangerEcran (int, String)
+ Affiche ()

1
0..*
Ecran
Peripherique
- Taille : double
- Marque : String - Type : String
- Marque : String
+ Ecran (double, String)
- Pilote : String
+ toString () : String
+ Peripherique(String, String, String)
+ toString () : String

Disque
- Capacité : int
- Catégorie : String

public class Ecran + Disque (Entier, Chaîne)

{ 1..* + toString () : Chaîne
private double Taille ;
private String Marque;
public Ecran (double t, String m)
{Taille=t; Marque=m;}
public String toString ()
{return ("Ecran :" + Marque + ", Taille : " + Taille);}
}

public class Disque

{private int Capacite;
private String Categorie;
public Disque (int cap, String c) {Capacite=cap; Categorie=c ;}
public String toString ()
{return ("Disque : " + Categorie + " ,Capacité : " + Capacite) ;}
}

Enseignante : Afifa Khélifa Zguerni Page 22

Cours : Programmation Orientée Objet Chapitre3 : L’encapsulation, la surcharge et l’agrégation

public class Peripherique

{
private String Type, Marque, Pilote ;
public Peripherique (String t, String m, String p)
{Type=t; Pilote= p; Marque=m;}
public String toString ()
{return("Type:" + Type + ",Marque:" + Marque + ",Pilote:" + Pilote););
}
}
public class Ordinateur
{ private String NumSerie, Marque, Processeur, Memoire;
private double Prix ;
private Ecran monEcran ;
private Disque [] ListeDisque ;
private Peripherique [] ListePeripherique ;
private int Nbd, Nbp;
public Ordinateur (String n, String m, String p, String mem, double
pr, int ca, String cdisque)
{
NumSerie=n; Marque = m; Processeur = p; Memoire=m; Prix=pr;
ListeDisque = new Disque [5] ;
ListeDisque [0]=new Disque (ca, cdisque) ;
Nbd=1;
ListePeripherique = new Peripherique [20];

}
public void AjouterDisque (int cap, String c)
{ListeDisque [Nbd]= new Disque (cap, c) ; Nbd++ ;}
public void AjouterPeripherique (String t, String m, String p)
{ListePeripherique [Nbp]= new Peripherique (t, m, p);
Nbp++;}
public void ChangerEcran (int t, String m)
{monEcran = new Ecran (t, m);}
public void Affiche ()
{System.out.println ("NumSerie: " + NumSerie + ", Marque:" +
Marque + ", Processeur : " + Processeur + ", Mémoire : " +
Memoire + "Prix : " + Prix) ;
System.out.println (monEcran.toString()) ;
for(int i=0; i<Nbd; i++)
System.out.println (ListeDisque[i].toString());
for(int i=0; i<Nbp; i++)
System.out.println (ListePeripherique[i].toString());
}
}

public class Test

{ public static void main (String [] argv)
{Ordinateur Or;
Or=new Ordinateur ("123-234", "Toshiba100","Intel 1.6GHZ", "RAM
1GO",1000.299, 100, "Disque dur" );
Or.AjouterDisque (8,"Dique Amovible") ;
Or.ChangerEcran (15, "Ecran plug and play ") ;
Or.AjouterPeripherique ("Souris", "PS/2","Microsoft 5.1.2600.0") ;
Or.AjouterPeripherique("Clavier","Standard101/102touches", "Microsoft
5.1.2600.2180 ") ;
Or.Affiche () ;
}
}

Enseignante : Afifa Khélifa Zguerni Page 23