UEF4.3.

PROGRAMMATION
ORIENTÉE OBJET

Mme SADEG et Mme Bousbia

s_sadeg@esi.dz, n_bousbia@esi.dz
Ecole nationale Supérieure d’Informatique
(ESI)
CLASSES ABSTRAITES
ET INTERFACES
 3

Problème
•  On souhaite disposer d’une hiérarchie de classes
permettant de manipuler des figures
géométriques. On veut qu’il soit toujours possible
d’étendre la hiérarchie en dérivant de nouvelles
classes mais on souhaite pouvoir imposer que
ces dernières disposent toujours des méthodes
suivantes :
•  void calculerSuperficie ()
•  void calculerPerimetre ()
•  void afficher()

•  Quelle solution proposez vous?

 4

Les classes abstraites

Une classe abstraite est une classe qui ne peut pas être
instanciée. Elle ne peut servir que de classe de base pour
être dérivée.

abstract class A {……}

Dans une classe abstraite on trouve des méthodes et des

attributs mais aussi des méthodes dites abstraites.
C’est-à-dire, des méthodes dont on fournit uniquement la
signature et le type de la valeur de retour

abstract class A
{ public void f(){….}
public abstract void g (int n);
}
 5

Les classes abstraites

Quelques règles

1.  Une classe qui comporte une ou plusieurs méthodes

abstraites est abstraite. Et de ce fait, elle ne sera pas
instanciable
2.  Une méthode abstraite ne peut pas être privée (puisqu’elle
est destinée à être redéfinie dans une classe dérivée)
3.  Une classe dérivée d’une classe abstraite n’est pas obligée
de redéfinir toutes les méthodes abstraites de sa classe de
base et peut même n’en redéfinir aucune et restera abstraite
elle-même
4.  Une classe dérivée d’une classe non abstraite peut être
déclarée abstraite et / ou contenir des méthodes abstraites
 6

Solution au problème
•  Il suffit de créer une classe abstraite Figure
disposant des en-têtes des méthodes qu’on
souhaite voir redéfinies dans les classes
dérivées, en leur associant le mot clé abstract :

abstract class Figure {

abstract public void afficher() ;
abstract public void calculerSuperficie();
abstract public void calculerPerimetre();
…
}
 7

Solution au problème

•  Les classes decendantes de la hiérarchie de

figures seront alors simplement définies comme
classes dérivées de Figure et elles devront
redéfinir les méthodes abstraites, par exemple :

class Triangle extends Figure {

public void afficher() {…..}
public void calculerSuperficie(){….}
public void calculerPerimetre(){….}
}
 8

Intérêt des classes abstraites

•  Les classes abstraites facilitent la conception
orientée objet car elles permettent de placer dans
une classe toutes les fonctionnalités dont doivent
disposer toutes ses descendantes:

•  Soit sous forme complète de méthodes (non

abstraites) et de champs (privés ou non)
communs à toutes les classes ascendantes

•  Soit sous forme d’interface de méthodes

abstraites dont on est sûr qu’elles existeront dans
toute classe dérivée
 9

Problème
Reprenons la hiérarchie des classes des figures
géométriques et supposons que, pour les besoins
d’une applications, on souhaite que seuls les
carrés et les cercles puissent se déplacer (position
du centre pour le cercle et du coin gauche
supérieure pour le carré).

Que proposez vous comme solutions ?

 10

Solutions

Modifier la hiérarchie des classes Créer une classe utilitaire

Ajouter une méthode (créer une classe abstraite contenant une méthode
abstraite Deplacable dont héritent Cercle déplacer (int x, int y) qui sera
deplacer(int dx, int dy) et le Carré et la doter d’une appelée au niveau des classes
dans Figure méthode deplacer(int dx, int dy). Cercle et Carré

1 2 3

x  Ceci rendra les objets x  Parfois la hiérarchie des classes x  Cet appel n’est pas
de type triangle et n’est pas modifiable.
obligatoire.
rectangle déplaçables x  Dans certains cas ce
Les programmeurs de
ce qui ne correspond comportement peut être
Cercle et de Carré
pas aux contraintes commun à des classes
peuvent donc l’omettre
imposées n’appartenant pas à la même
ou l’ignorer.
hiérarchie
 11

Les interfaces
•  Si on considère une classe abstraite n’implantant aucune
méthode et aucun champ (hormis des constantes),
on aboutit à la notion d’interface

•  Une interface définit les en-têtes d’un certain nombre de

méthodes, ainsi que des constantes.

•  Si une classe implémente une interface, elle s’engage à

fournir un code à ses méthodes (même vide)
 12

Les interfaces
Définition d’une interface

On définit une interface comme on définit une classe en

remplaçant le mot clé class par interface

public interface I{
final int MAX = 100;
void f(int n);// public et abstract sont facultatifs
void g();
}

Les méthodes d’une interface sont toutes abstraites et

publiques, il n’est donc pas obligatoire de le mentionner
 13

Les interfaces
Implémentation d’une interface
Une classe peut implémenter une interface
class A implements I
{// A doit redéfinir les méthodes de I sinon erreur à la
compilation}

Une classe peut implémenter plusieurs interfaces

public interface I1 {
void f();
}
public interface I2{
void g()
}
class A implements I1,I2
{// A doit définir les méthodes f et g
}
 14

Variables de type interface et polymorphisme

Il est possible de définir des variables de type interface

public intarface I { …. }
…
I i; //i est une référence à un objet d’une classe
//implémentant l’interface I

class A implements I {….}

…
I i = new A(…); // ok
 15

Dérivation d’une interface

On peut définir une interface comme étant dérivée d’une autre

interface (mais pas d’une classe) en utilisant le mot clé extends.

interface I1 interface I2
{ {
static final MAXI = 100; static final MINI = 10;
void f (int n); static final MAXI = 100;
} void f (int n);
interface I2 extends I1 void g();
{ }
static final MINI = 10;
void g();
}
 16

Dérivation d’une interface

Une interface peut dériver de plusieurs interfaces.
L’héritage multiple est autorisé pour les interfaces

interface I1 {
void f();
}
interface I2 {
void f1();
}
interface I3 extends I1,I2 {
void f2();
}
 17

Conflits de noms
Exemple 1
interface I1{
void f (int n);
void g();
}

interface I2{
void f(float x);
void g();
}

class A implements I1,I2{

/* Pour satisfaire I1 et I2, A doit définir
deux méthodes f: void f(int) et void f(float),
mais une seule méthode g: void g()*/
}
 18

Conflits de noms
Exemple 2
interface I1{
void f (int n);
void g();
}
interface I2{
void f(float x);
int g();
}
class A implements I1,I2{
/* Pour satisfaire I1 et I2, A doit contenir à la
fois une méthode void g() et une méthode int
g(), ce qui est impossible d’après les règles de
surdéfinition. Une classe ne peut implémenter
les interfaces I1 et I2 telles qu’elles sont
définies dans cet exemple*/
}
 19

Méthodes « default »
•  Avant java 8 une interface ne pouvait contenir que des
entêtes de méthodes et ne fournissait pas
l’implémentation de ces méthodes.
•  Chaque classe dérivée (implémentant cette interface)
s’engager à fournir sa propre implémentation.

•  Depuis java 8, il est permis de fournir une implémentation

aux méthodes dans les interfaces.
 20

Méthodes « default »
syntaxe
public interface I {

/** Pas d'implémentation */

public void m1();

/** Implémentation par défaut*/

default void m2() {

// corps de la méthode
}

}
 21

Méthodes « default »
utilité
•  Les méthode par défaut permettent de faire évoluer
une interface sans que cela pose problème au
niveau des classes qui l’implémentent.
•  Exemple : cas des interfaces des API java.

•  Les classes qui partagent la même implémentation

d’une méthode d’une interface ne sont plus obligées
de répéter le même code chacune à son niveau
 22

Méthodes « default »
possibilités d’utilisation
•  Une classe implémentant une interface comportant
une méthode par défaut (default) peut :
•  Utiliser directement cette méthode
•  Redéfinir cette méthodes

•  Une interface I2 dérivant d’une interface I1 peut:

•  Hériter de l’implémentation de la méthode par défaut
•  Redéfinir une méthode par défaut
•  La déclarer à nouveau, ce qui la rend abstraite
 23

Méthodes « default »
règles d’utilisation

•  Si deux interfaces I1 et I2 déclarent la même méthode

m() mais proposent des implémentations incompatibles,
que se passe-t-il pour la classe implémentant ces deux
interfaces?

•  La classe doit redéfinir la méthode pour résoudre le

conflit.

•  Pour appeler la méthode par défaut d’une des deux

interfaces, une syntaxe particulière a été ajoutée:
I2.super.m();
 24

Méthodes statiques dans les interfaces

•  C’est une autre nouveauté de java 8.

•  Les interfaces peuvent contenir des méthodes statiques

et elles sont utilisées exactement de la même manière
que celles que peuvent contenir des classes.
 25

Exemple de l’interface Comparable

•  Une classe implémente l’interface Comaprable si

ses objets peuvent être ordonnés selon un ordre
particulier.
•  Par exemple la classe String implémente
Comparable parce que les chaines de caractères
peuvent être ordonnées selon l’ordre alphabétiques.

•  Les classes numériques comme Integer et Double

implémentent Comparable parce que les nombres
peuvent être ordonnés selon l’ordre numérique
 26

Exemple de l’interface Comparable

•  L’interface Comparable consiste en une seule
méthode (et pas de constantes) :
int compareTo(T obj)
qui compare l’objet à un objet de type T
•  A.compareTo(B)retourne :
•  un entier négatif si l’objet A est plus petit que B,
•  zéro si les deux objets sont égaux, et
•  un entier positif si l’objet A est plus grand que l’objet B.
•  Exemple:
"Bonjour ".compareTo ("Bonsoir ") renvoie un entier négatif.
 27

Différences entre interface et héritage

•  Une interface fournit un contrat à respecter sous forme
d’en-tête de méthodes auxquelles la classe
implémentant l’interface s’engage à fournir un corps
(qui peut être vide ou contenir des instructions).

•  Des classes différentes peuvent implémenter

différemment une même interface alors que les classes
dérivées d’une même classe de base partagent la
même implémentation des méthodes héritées

•  Même si Java ne dispose pas de l’héritage multiple, ce

dernier peut être remplacé par l’utilisation d’interfaces,
avec l’obligation d’implémenter les méthodes
correspondantes.
 28

Exercice

Créez une classe CompteEnBanque munie d’un

seul attribut solde, et définissez l’égalité de deux
objets comptes en banque, de telle manière qu’elle
soit vérifiée dès lors que les deux soldes sont
égaux.
 29

Solution
class CompteEnBanque implements Comparable{

private float solde;

public float getSolde(){ return solde;}

public void setSolde(float s){ solde=s;}

public int compareTo(Object cmp) {

float solde2 = ((CompteEnBanque)cmp).getSolde();

if(this.solde>solde2)
return 1;
else if(this.solde <solde2)
return -1;
else
return 0;
}
}
PAQUETAGES
 31

Les paquetages
•  Un paquetage est un ensemble de classes regroupées
sous le même identificateur. Cette notion est proche de
celle de bibliothèque dans d’autres langages.

•  L’organisation des classes en paquetages facilite le

développement de logiciels de taille importante car les
conflits de noms sont limités aux classes appartenant au
même paquetage.
 32

La notion de paquetage est logique

•  La notion de paquetage est « logique » et n’a pas de rapport
avec l’emplacement effectif des classes ou des fichiers au
sein des répertoires.

•  Quand on utilise des noms de paquetage hiérarchisés, il ne

s’agit que d’une organisation logique des noms de
paquetages. En effet pour désigner simultanément
utilitaires.Mathématiques et utilitaires.Tris, on ne peut
pas se contenter de citer Utilitaires.

•  Si aucun nom de paquetage n’est spécifié (pas d’instruction

package), le compilateur considère que les classes
correspondantes appartiennent au paquetage par défaut.
 33

Utilisation d’une classe d’un paquetage

•  Lorsqu’une classe est référencée dans un
programme, le compilateur la recherche dans le
paquetage par défaut.
•  Pour utiliser une classe appartenant à un autre
paquetage, il faut « informer » le compilateur et
pour cela on peut :
1.  Citer le nom du paquetage avec le nom de la classe
2.  Utiliser l’instruction import en citant une classe
particulière d’un paquetage
3.  Utiliser l’instruction import en citant tout un paquetage
 34

Utilisation d’une classe d’un paquetage

1. En citant le nom de la classe

•  Si par exemple on attribue à la classe Point le nom de

paquetage MesClasses, on peut l’utiliser simplement en la
nommant Mesclasses.Point:

MesClasses.Point p= new MesClasses.Point(3,5);

….
p.affiche();

Cette démarche peut s’avérer fastidieuse si de nombreuses

classes sont concernées
 35

Utilisation d’une classe d’un paquetage

2. En important une classe

L’instruction import permet d’importer le nom d’une ou

plusieurs classes. Le nom doit être complet.

import MesClasses.Point, MesClasses.Cercle;

A partir de là, les classes Point et Cercle pourront être

utilisées sans avoir à mentionner le nom du paquetage.

Si un certain nombre de classes du même paquetage sont

concernées, la troisième possibilité est préférable.
 36

Utilisation d’une classe d’un paquetage

3. En important un paquetage

Pour utiliser toutes les classes d’un même paquetage, il

suffit d’importer le paquetage entier:

import MesClasses.*;

Attention, si on a créé un paquetage appelé

MesClasses.TP, ses classes ne seront pas concernées par
cette instruction.
 37

Utilisation d’une classe d’un paquetage

Remarques

•  Si deux paquetages contenant des classes de même nom sont

importés, cela constitue une erreur.
•  Citer un paquetage sans utiliser toutes ses classes n’augmente ni le
temps de compilation ni la taille des fichiers .class générés. L’utilité du
filtrage est de limiter les ambiguïtés en cas de classes de noms
similaires entre différents packages importés.
•  La plupart des environnements imposent des contraintes concernant
l’emplacement des fichiers correspondant à un paquetage.
•  Un paquetage de nom X.Y.Z se trouve toujours entièrement dans un
sous-répertoire appelé X.Y.Z.
•  Mais le paquetage X.Y.U qui se trouve dans le sous répertoire X.Y.U
peut se trouver dans un répertoire différent de celui de X.Y.Z.
•  Avec le SDK (ou JDK), la recherche d’un paquetage se fait dans les
répertoires déclarés dans la variable d’environnement CLASSPATH
 38

Les paquetages standard

•  Les classes standard fournies avec java sont structurées
en paquetages comme par exemple java.awt,
java.awt.event, javax.swing…

•  Il existe un paquetage particulier nommé java.lang qui est

automatiquement importé par le compilateur et qui permet
d’utiliser les classes standard telles que Math, System,
Float ou Integer, Double, Object…
 39

Paquetages et droits d’accès

Droits d’accès aux classes

Chaque classe dispose d’un droit d’accès (ou modificateur d’accès)

qui permet de décider quelles sont les autres classes qui peuvent
l’utiliser.
Le droit d’accès est précisé par la présence ou l’absence du mot clé
public:
•  Avec le mot clé public, la classe est accessible à toutes les autres
classes (en ayant éventuellement recours à une instruction import)
• Sans le mot clé public, la classe n’est accessible qu’au classes du
même paquetage
Tant que l’on travaille avec le paquetage par défaut, le mot clé public
est facultatif sauf pour la classe contenant la méthode main qui doit
être publique pour que la JVM puisse y avoir accès
 40

Paquetages et droits d’accès

Droits d’accès aux membres d’une classe

Nous avons déjà vu qu’on pouvait utiliser pour un

membre (champs ou méthode) l’un des modificateurs
d’accès
•  public (le membre est accessible de l’extérieur de la classe),
•  private (le membre n’est accessible qu’aux méthodes de la
classe) et
•  protected (le membre est accessible par les classes
dérivées).
 41

Paquetages et droits d’accès

Droits d’accès aux membres d’une classe
Il existe une quatrième possibilité qui est l’absence de
modificateurs d’accès qui limite l’accès aux classes du même
paquetage. Ce droit d’accès est appelé accès paquetage.

package P2
class B// accessible uniquement dans
package P1; p2
public class A // accessible partout {…
{… public void g()
void f1() {….} { A a = new A();
public void f2(); {…} a.f1(); // interdit
} a.f2(); // OK
}
}
 42

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

(droit de paquetage) classes du même paquetage
 43

Modificateurs d’accès pour les membres et les classes

internes
Modificateur Signification pour un membre d’une classe
(champs ou méthode) ou une classe interne

public Accès possible partout où sa classe est

accessible
néant (droit de Accès possible depuis toutes les classes du
paquetage) même paquetage (quelque soit le droit d’accès de
la classe qui est au minimum celui du 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ù est faite la

déclaration du membre ou de la classe interne