Chapitre 4 :

Les Modificateurs, les

packages et les
interfaces.
Dr. A. Nejeoui

! POO JAVA: GI2

 INTRODUCTION
Dans les 3 premiers chapitres sur le langage java, vous avez appris à
construire des classes, créer des objets instances de ces classes et
manipuler les variables et méthodes d’instances / de classes.
Dans ce chapitre vous allez approfondir vos connaissances concernant les
classes. On va couvrir les points suivants :
▪ Contrôler l’accès aux variables et méthodes en dehors de la classe
▪ Le mot clef final (variable, méthode et classe)
▪ Les méthodes et classes abstraites
▪ Regroupement des classes en packages
▪ Les interfaces
▪ les méthodes default et static dans une interface

" POO JAVA: GI2

 MODIFICATEURS
Un modificateur est un mot clé que vous ajoutez devant l’identificateur
d’une classe, méthode, variable ou interface pour modifier sa signification.
Java définit une variété de modificateurs dont on peut citer :
Les modificateurs de contrôle d’accès : public, private et protected
(classe, interface, méthode et variable)
Le modificateur static pour déclarer une méthode ou une variable de
classe.
Le modificateur final (classe, interface, méthode ou variable)
Le modificateur abstract pour créer des classes et des méthodes
abstraites.
Les modificateurs synchronized et volatile qui sont utilisés avec les
threads.

# POO JAVA: GI2

UTILISATION DES MODIFICATEURS
Pour utiliser un modificateur, vous le placez devant l’élément qu’il modifie
que ce soit une classe, une interfaces, une méthode ou une variable.
Le modificateur doit être placé avant le reste de l’instruction. Exemple :
public class Test {
private final int n=0;
}
Dans le cas ou vous avez à utiliser plusieurs modificateurs avec le même
élément. Vous pouvez les mettre dans n’importe quel ordre tant qu’ils
sont tous placés devant l’élément qu’ils modifient.
Attention
Le type de retour d’une méthode n’est pas un modificateur, les
modificateurs sont optionnels !

$ POO JAVA: GI2

 LES MODIFICATEURS DE
CONTRÔLE D’ACCÈS
Les modificateurs de contrôle d’accès sont : private, protected, public et
« package lorsque aucun des trois autres modificateurs ni mentionné».
Ils permettent de contrôler la visibilité d’une classe, d’une interface,
d’une méthode ou d’une variable ».
Modificateur d’accès par défaut « package »:
un élément modifié avec le modificateur de contrôle d’accès par défaut est
visible dans toutes les classes qui appartiennent au même package de
cet l’élément.
Exemples :
class A{
String nom="Ahmed"
int fct(){return 0;}
}
% POO JAVA: GI2
 PRIVATE
Remarques :
▪ vous ne pouvez modifier l’accès à un élément avec plus q’un seul
modificateur de contrôle d’accès. Ainsi l’instruction
public protected int n; //est invalide
▪ Une classe ou interface ne peut être déclarée protected ni private.
private
Le modificateur de contrôle d’accès private est utilisé pour limiter l’accès
aux méthodes et aux variables membres d’une classe. Une variable ou
méthode déclarée private est visible seulement dans le corps de sa
classe, aucune autre classe ne peut y accéder.
Une méthode/variable peut être déclarée private dans les cas suivants:
▪ Lorsque les autres classes n’ont aucune raison pour l’utiliser.
▪ Lorsque l’accès à cette méthode/variable affecte la sécurité du système.
▪ Pour séparer la spécification de la réalisation.

& POO JAVA: GI2

 PRIVATE
Dans cet exemple le nom est une variable privé de la classe Citoyen . Donc
aucune autre classe ne peut y accéder ni en lecture ni en écriture. Pour la
manipuler on a défini deux méthodes publiques getNom et setNom.

' POO JAVA: GI2

 PUBLIC ET PROTECTED
Dans certains cas on a besoins de rendre un élément (classe, interface,
méthode ou variable) accessible à toutes les autres classes. Dans ce cas
on doit le déclarer avec le modificateur public.
Le modificateur de contrôle d’accès protected utilisé avec une méthode ou
variable membre limite l’accès à cette dernière aux deux groupes
suivants:
1- Les sous classes qui possèdent la méthode ou la variable membre.
2- Les classes dans le même package.
Ces deux groupes sont distincts car on peut avoir une sous classe déclarée
dans un package autre que celui de sa superclasse.
Ce genre de modificateur d’accès est utile lorsque vous voulez bénéficier
de l’héritage sans toutefois déclarer une méthode/variable public.

( POO JAVA: GI2

 MODIFICATEUR DE CONTRÔLE
D’ACCÈS ET L’HÉRITAGE
Avant d’appliquer un modificateur de contrôle d’accès à une méthode
redéfinie il faut considérer la règle suivante:
On ne peut pas redéfinir une méthode et réduire sa visibilité.
Ainsi :
Les méthodes déclarées public dans la superclasse doivent être redéfinies
public dans les sous-classes.
Les méthodes déclarées protected dans la superclasse doivent être
redéfinies soit protected soit public dans les sous-classes.
Les méthodes déclarées sans modificateur de contrôle d’accès dans la
superclasse peuvent être déclarées soit package soit protected soit
public dans les sous-classes.
Les méthodes private ne sont pas visibles donc ils ne sont pas héritées.
Si vous essayer de réduire la visibilité d’une méthode vous aurez une erreur
de compilation du type : " Cannot reduce the visibility of the inherited
method "

) POO JAVA: GI2

 LES MODIFICATEURS DE
CONTRÔLE D’ACCÈS
class c1 { Package P1 Package P2
public int A;
protected int B;
int C; class c4 extends c1 {
private int D; ...
} }

class c2 extends c1 { class c3 { class c5 {

... ... ...
} } }

A B C D
Accessible par c1 o o o o
Accessible par c2 o o o -
Accessible par c3 o o o -
Accessible par c4 o o - -
Accessible par c5 o - - -

!* POO JAVA: GI2

 LE MODIFICATEUR STATIC
static et la redéfinition
Le concept de redéfinition est lié au méthodes d’instance, Java ne permet
pas de redéfinir les méthodes de classes (static).
static et la surcharge :
Une méthode de classe peut surcharger une méthode d’instance
Une méthode d’instance peut surcharger une méthode de classe.

!!POO JAVA: GI2

 LE MODIFICATEUR FINAL
Le modificateur final peut être utilisé avec une classe, méthode ou variable
pour indiquer qu’elle ne peut pas changer. Ce modificateur a plusieurs
significations selon l’élément qu’il modifie :
Une classe final ne peut être sous classée
Une méthode final ne peut être redéfinie
Une variable(membre ou locale) final ne peut changer de valeur.
Remarques:
On ne peut pas déclarer une classe abstraite final.
On ne peut pas déclarer une interface final.
Le modificateur final peut modifier, une classe, une méthode, une variable
membre, un argument d’une méthode ou encore une variable locale.

!" POO JAVA: GI2

 OBJETS IMMUABLES
Pour créer des classes immuables
1- Eviter les modificateurs
2- Déclarer les variables membres final
3- Interdire la redéfinition des méthodes
4- Pour toute variable membre de type référence
a-Eviter les modificateurs qui modifient une partie de l’état de cette
variable.
b-Ne pas partager la référence à cette variable (si nécessaire créer une
copie)

!# POO JAVA: GI2

 OBJETS IMMUABLES

!$ POO JAVA: GI2

 LE MODIFICATEUR ABSTRACT
Dans la hiérarchie des classes, plus une classe est placée en haut plus il
devient plus abstraite car elle factorise des éléments d’état et de
comportement plus généraux.
Parfois à force de la diversité de l’implémentation d’un comportement
donné par les différentes sous classes candidates, le développeur se
trouve devant une situation où l’intersection entre les différents
comportements est réduit à l’ensemble vide.
Dans ce cas, pour tirer profit des bénéfices du polymorphisme java fournit
la notion de méthode abstraite.
Definitions :
1-Une méthode abstraite est une méthode sans code (seulement la
signature et le type de retour).
2-Une classe abstraite est une classe qui ne peut être instanciée.
Une méthode abstraite est déclarée suivant la syntaxe :

abstract typeRetour nomMethode(type1 arg1, type2 arg2,…);

!% POO JAVA: GI2

 LE MODIFICATEUR ABSTRACT
Une méthode abstraite ne peut être final ni private.
Une classe est automatiquement abstraite dès qu'une de ses méthodes
est déclarée abstraite.
On peut définir une classe abstraite qui ne contient aucune méthode
abstraite.

!& POO JAVA: GI2

 LES INTERFACES
Une interface est un protocole de communication entre objets.
Le langage Java support les interfaces que vous utilisez pour définir un
protocole de comportement qui peut être implémenté par toute classe
dans la hiérarchie des classe.
Une interface définit un ensemble de méthodes. Chaque classe qui
implémente cette interface accepte d’implémenter toutes les méthodes
non default définies dans l’interface, par conséquent accepter un certain
comportement.

Définition: une interface est une collection « nommée » de définitions de

méthodes (sans implémentations). Une interface peut aussi déclarer des
constantes, des méthodes statiques et définir un comportement par
défaut d’une méthode.

!' POO JAVA: GI2

 LES INTERFACES

!( POO JAVA: GI2

 DIFFÉRENCE ENTRE INTERFACE ET
CLASSE ABSTRAITE
Parce que une interface est simplement une liste de méthodes sans
implémentation, cela génère une confusion avec les classes abstraites.
Mais ces deux notions sont largement distincts:
Une interface ne peut implémenter aucune méthode. Mais une classe
abstraite le peut.
Une classe peut implémenter plusieurs interfaces mais ne peut avoir plus
qu’une seule superclasse.
Une interface ne fait pas partie de l’hiérarchie des classes. Des classes
qui n’ont aucune relation d’héritage peuvent implémenter la même
interface.

!) POO JAVA: GI2

 DÉCLARATION D’UNE INTERFACE
access interface nom extends SuperInterface1, SuperInterface2… {
ret-type nom-method-1(liste-param1);
ret-type nom-method-2(liste-param2);
default nom-method-3(liste-param3){
// comportement par défaut de la méthode 3
}
static nom-method-4(liste-param4){
// comportement de la méthode statique 4
}
// ...
ret-type nom-method-N(liste-param);

type var1 = valeur;

type var2 = valeur;

type varN = valeur;

}
"* POO JAVA: GI2
 DEFAULT MÉTHODES

"! POO JAVA: GI2

 MÉTHODES STATIQUES DANS UNE
INTERFACE
Java 8 permet de declarer des méthodes statiques avec un corps dans les
interfaces, les méthodes statiques dans une interfaces servent a
regrouper les comportement qui ne dépendent pas d’un objet spécifique
dans une interface.
Les méthodes statiques dans une interfaces ne peuvent être redéfinies
dans la classe qui implémente cette interface, la redéfinition est une
notion liée aux méthodes d’instance.
NB :
Les méthodes statiques dans une interfaces sont invisibles dans classes
qui implémentent cette interface. Pour les utiliser il faut les invoquer via le
nom de l’interface.

"" POO JAVA: GI2

 MÉTHODES STATIQUES DANS UNE
INTERFACE

"# POO JAVA: GI2

 INTERFACES FONCTIONNELLES
Dans java 8 une interface qui définit une seule méthode abstraite s’appelle une
interface fonctionnelle, une nouvelle annotation a été introduit pour forcer le
compilateur a vérifier si l’interface est fonctionnelle @FunctionalInterface.

"$ POO JAVA: GI2

 CONFLIT DANS LE CAS DE
L’HERITAGE MULTIPLE
Lorsque une classe
implémente deux
interfaces qui déclarent
deux méthodes avec la
même signature cela
crée un conflit dans la
classe :
Si les deux methods sont
non default : une seule
implémentation suffit.
Si l’une des deux methods
est default il faut redéfinir
la méthode dans la
classe qui implémente
les deux interfaces.

"% POO JAVA: GI2

 PACKAGES
Définition :
Un package est un groupe de classes associées à une fonctionnalité
ou qui coopèrent.

L’utilisation des packages permet d’organiser un groupe de classes qui

réalisent une fonctionnalité donnée sous un nom.
Exemples :
java.util, javax.faces , org.lwjgl, java.awt.images …
Les packages offrent plusieurs avantages :
1- ils facilitent l’organisation des classes. Juste comme les répertoires
facilitent l’organisation des fichiers.(la recherche d’une classe devient plus
facile : exemple ma.ac.ensa.front et ma.ac.ensa.back
2- Ils offrent un mécanisme supplémentaire de protection de classes,
méthodes et attributs (le modificateur de contrôle d’accès par défaut)
3- ils résolvent les problèmes de conflit de nom exemple : java.util.Date et
java.sql.Date
4- ils permettent d’identifier votre travail d’une manière unique.(marketing
gratuit)
"& POO JAVA: GI2
 ACCÈS À UNE CLASSE D’UN
PACKAGE
Le nom du package fait partie du nom de la classe.
Pour pouvoir utiliser une classe déclarée dans un autre package il faut
indiquer son emplacement au compilateur, il y’a trois manière de faire
cela:
1. Importer la classe (import java.util.Date ;)
2. Importer tout le package où la classe est définie (import java.util.* ;)
3. Utiliser le nom complet de la classe (java.util.Date date;).

"' POO JAVA: GI2

 IMPORT STATIC
Jusqu'à la version 1.4 de Java, pour utiliser un membre statique d'une
classe, il faut obligatoirement préfixer ce membre par le nom de la classe
qui le contient
Java 1.5 propose une solution pour réduire le code à écrire concernant les
membres statiques en proposant une nouvelle fonctionnalité concernant
l'importation de package : l'import statique (static import).
Java 1.8 étends cette syntaxe pour importer les méthodes statiques
définies dans une interface

"( POO JAVA: GI2

 CONCLUSION

Dans ce chapitre voua avez appris à :

Utiliser les modificateurs Java suivants : public protected <<package>>
private, static, final, abstarct, default.
Créer des classes immuables.
Déclarer et manipuler les méthodes et classes abstraites
Déclarer et implementer les interfaces
Définir une méthode default dans une interface
Définir une méthodes statique dans une interface
Manipuler les packages
Utiliser l’instruction : import static

") POO JAVA: GI2