Exceptions

Ce document a été fabriqué par PDFmail (Copyright RTE Multimedia)
http://www.pdfmail.com
La gestion des exceptions

Une exception est chargée de signaler un comportement

exceptionnel (mais prévu) d’une partie spécifique d’un
logiciel.
Dans les langages de programmation actuels, les
exceptions font partie du langage lui-même.
C’est le cas de Java qui intègre les exceptions comme
une classe particulière: la classe Exception.
Cette classe contient un nombre important de classes
dérivées.
Comment agit une exception ?

Dès qu’une erreur se produit comme un manque de
mémoire , un calcul impossible, un fichier inexistant,
un transtypage non valide,...,…ect.
un objet de la classe adéquate dérivée de la classe
Exception est instancié. Nous dirons que le logiciel
" déclenche une exception ".
Comment gérer une exception dans un

programme
Programme sans gestion de l'exception
le programme s'arrête et la java machine signale une

erreur.
---- java UseAction1
Début du programme
...Avant incident
java.lang.ArithmeticException : / by zero
---- : Exception in thread "main"
Dès que l'instruction "x = 1/0;" a été exécutée celle-ci a provoqué un
incident. En fait une exception de la classe ArithmeticException a été
"levée" (un objet de cette classe a été instancié) par la JVM.
La JVM n'a pas trouvé de code d'interception de

cette exception qui a été automatiquement levée.
Programme avec gestion de l'exception

Java possède une instruction de gestion des exceptions, qui
permet d'intercepter des exceptions dérivant de la classe
Exception :
try ... Catch
try {
<lignes de code à protéger>
}catch ( UneException E ) {
<lignes de code réagissant à l’exception UneException
>
}
Le type UneException est obligatoirement une classe qui
hérite de la classe Exception.
Schéma du fonctionnement d'un tel gestionnaire :

l'affichage obtenu sur la console lors de l'exécution de ce programme

Début du programme.
...Avant incident
Interception exception
Fin du programme.
---- : operation complete.
§ Nous remarquons donc que la Java machine a donc bien exécuté le
code d'interception situé dans le corps du
"catch ( ArithmeticException E ){...}" et a poursuivi l'exécution
normale après le gestionnaire.
§ Le gestionnaire d'exception se situe dans la méthode main (code
englobant) qui appelle la méthode meth() qui lève l'exception.
Interception d'exceptions hiérarchisées

Dans un gestionnaire try...catch, il est en fait possible
d'intercepter plusieurs types d'exceptions différentes et de
les traiter.
Ci-après nous montrons la syntaxe d'un tel gestionnaire
qui fonctionne comme un selecteur ordonné, ce qui
signifie qu'une seule clause d'interception est exécutée.
Dès qu'une exception intervient dans le < bloc de code à
protéger>, la JVM scrute séquentiellement toutes les
clauses catch de la première jusqu'à la nième.
Si l'exception actuellement levée est d'un des types
présents dans la liste des clauses le traitement associé est
effectué, la scrutation est abandonnée et le programme
poursuit son exécution après le gestionnaire.
try {
< bloc de code à protéger>
}
catch ( TypeException1 E ) { <Traitement TypeException1 > }
catch ( TypeException2 E ) { <Traitement TypeException2 > }
.....
catch ( TypeExceptionk E ) { <Traitement TypeExceptionk > }
Où TypeException1, TypeException12, ... , TypeExceptionk
sont des classes d'exceptions obligatoirement toutes distinctes.
Seule une seule clause catch ( TypeException E ) {...}est
exécutée (celle qui correspond au bon type de l'objet
d'exception instancié).
Ordre d'interception d'exceptions

hiérarchisées
Dans un gestionnaire try...catch comprenant plusieurs clauses, la recherche de la

clause catch contenant le traitement de la classe d'exception appropriée,
s’effectue séquentiellement dans l’ordre d’écriture des lignes de code.
La recherche va s'effectuer comme si le programme contenait des if...else if... imbriqués
if (<Objet exception> instanceof TypeException1) {Traitement TypeException1}
else if (<Objet exception> instanceof TypeException2) {Traitement TypeException2}
...
else if (<Objet exception> instanceof TypeExceptionk) {Traitement TypeExceptionk }
Les tests sont effectués sur l'appartenance de l'objet d'exception à une classe à l'aide de
l'opérateur instanceof.
Signalons que l'opérateur instanceof agit sur une classe et ses classes filles (sur une
hérarchie de classes),
On choisira donc, lorsqu’il y a une hiérarchie entre les exceptions à intercepter,
de placer le code de leurs gestionnaires dans l’ordre inverse de la hiérarchie.
Résultats de l'exécution :
UseAction2.java:19: exception java.lang.ArithmeticException has
already been caught
catch(ArithmeticException E){
UseAction2.java:22: exception java.lang.ArrayStoreException has
already been caught
catch(ArrayStoreException E){
UseAction2.java:25: exception java.lang.ClassCastException has
already been caught
catch(ClassCastException E){
3 errors Le compilateur proteste à partir de la clause catch
(ArithmeticException E )en nous indiquant que l'exception est déjà
interceptée et ceci trois fois de suite.
Que s'est-il passé ?

Le fait de placer en premier la clause
catch ( RuntimeException E ) chargée d'intercepter les
exceptions de classe RuntimeException implique que
n'importe quelle exception héritant de RuntimeException
comme par exemple ArithmeticException, est considérée
comme une RuntimeException. Dans un tel cas cette
ArithmeticException est interceptée par la clause catch (
RuntimeException E ) mais elle n'est jamais interceptée
par la clause catch (ArithmeticException E ).
Le seul endroit où le compilateur Java acceptera l'écriture
de la clause catch (RuntimeException E ) se situe à la fin
de la liste des clauses catch.
Redéclenchement d'une
exception : throw
Il est possible de déclencher soi-même des exceptions en utilisant

l'instruction throw, voir même de déclencher des exceptions
personnalisées ou non.
Déclenchement manuel d'une exception existante
La Java machine peut déclencher une exception automatiquement
comme dans l'exemple de la levée d'une ArithmeticException lors de
l'exécution de l'instruction "x = 1/0 ;".
La Java machine peut aussi lever (déclencher) une exception à votre
demande suite à la rencontre d'une instruction throw. Le programme qui
suit lance une ArithmeticException avec le message "Mauvais calcul !"
dans la méthode meth() et intercepte cette exception dans le bloc
englobant main. Le traitement de cette exception consiste à afficher le
contenu du champ message de l'exception grâce à la méthode
getMessage() :
Déclenchement manuel d'une exception personnalisée

Pour une exception personnalisée, le mode d'action est
strictement identique, il vous faut seulement auparavant
créer une nouvelle classe héritant obligatoirement de la
classe Exception ou de n'importe laquelle de ses sous-
classes.
Reprenons le programme précédent et créons une classe
d'exception que nous nommerons
ArithmeticExceptionPerso héritant de la classe des
ArithmeticException puis exécutons ce programme.
Exceptions vérifiées, non

vérifiées et erreurs
Toutes les erreurs et exceptions dérivent de la classe Trowable

Toutes les erreurs et exceptions dérivent de la classe Trowable
Erreurs non
réparables
Exceptions
vérifiées
Exceptions (d’exécution) non

vérifiées
Signale un problème qui risque d’être fatal

Erreurs non au programme.Ne récupérer pas Errors dans
réparables votre code java.
C’est à vous de choisir ce que vous voulez

Exceptions faire de ces exceptions d’exécution.
(d’exécution)
non vérifiées
Elles doivent être récupérées et gérées

Exceptions quelque part dans votre application.
vérifiées
La majorité des exceptions de Java font partie du package

java.lang.
Certaines exceptions sont tellement courantes qu'elles ont
été rangées par Sun (concepteur de Java) dans une
catégorie dénommée la catégorie des exceptions
implicites ou non vérifiées (unchecked), les autres sont
dénommées exceptions explicites ou vérifiées (checked)
selon les auteurs.
Une exception non vérifiée (implicite) est une classe
dérivant de l'une des deux classes
Error ou RuntimeException
Toutes les exceptions vérifiées ou non fonctionnent de la même

manière, la différence se localise dans la syntaxe à adopter dans une
méthode propageant l'un ou l'autre genre d'exception.
Nous pouvons déjà dire que pour les exceptions non vérifiées, il n'y a
aucune contrainte syntaxique pour propager une exception d'une
méthode vers un futur bloc englobant. La meilleure preuve de notre
affirmation est qu'en fait nous n'avons utilisé jusqu'ici que des
exceptions non vérifiées, plus précisément des exceptions dérivant de
RuntimeException et que nous n'avons utilisé aucune syntaxe
spéciale dans la méthode meth() pour indiquer qu'elle était
susceptible de lever une exception :
Méthode propageant une

exception vérifiée
Une méthode dans laquelle est levée une ou plusieurs exceptions

vérifiées doit obligatoirement signaler au compilateur quelles sont les
classes d'exceptions qu'elle laisse se propager sans traitement par un
gestionnaire (propagation vers un bloc englobant).
Java dispose d'un spécificateur pour ce signalement : le mot clef
throws suivi de la liste des noms des classes d'exceptions qui sont
propagées.
Signature générale d'une méthode propageant des exceptions
vérifiées
Redéfinition d'une méthode

propageant des exceptions
vérifiées
Principe de base : la partie throws < liste d'exceptions>

de la signature de la méthode qui redéfinit une méthode
de la super-classe peut comporter moins de types
d'exception. Elle ne peut pas propager plus de types ou
des types différents de ceux de la méthode de la super-
classe.
Ci-après un programme avec une super-classe Action4
et une méthode meth(), qui est redéfinie dans une classe
fille nommée Action5
Notez que la méthode meth

de la super-classe propage
IOException et
NoSuchFieldException
bien qu'elle ne lance qu'une
exception de type
IOException;
ceci permettra la redéfinition
dans la classe fille.
Listing des 3 exécutions dans chacun des cas d'appel de Résultats de l'exécution
la méthode meth :
Résultats de l'exécution
Début du programme. Appel meth(2)
Appel meth(0) ...Avant incident-fille
...Avant incident-fille Interception exception_2 :
...Avant incident-mère Problème de champ !-fille
Interception exception_0 : Problème conversion de Fin du programme.
caractère !-mère
Fin du programme.
Résultats de l'exécution
Appel meth(1)
...Avant incident-fille
Interception exception_1 : Problème d'E/S !-fille
Fin du programme.
Clause finally
Supposons que nous soyons en présence d'un code

contenant une éventuelle levée d'exception, mais
supposons que quoiqu'il se passe nous désirions
qu'un certain type d'action ait toujours lieu (comme
par exemple fermer un fichier qui a été ouvert
auparavant). Il existe en Java une clause spécifique
optionnelle dans la syntaxe des gestionnaires
d'exception permettant ce type de réaction du
programme, c'est la clause finally. Voici en pseudo
Java une syntaxe de cette clause :
<Ouverture du fichier>
try {
< action sur fichier>
}
finally {
<fermeture du fichier>
}
.... suite
Création de ses propres

exceptions
Exemple 1
class Pile{
private int table [] ;
private int hauteur = 0 ;
public Pile () { table = new int [3] ; }
public Pile (int h) { table = new int [h] ; }
public void insertValue (int valeur) throws PileException{
if (hauteur == table.length) throw new PileException ("Pile
pleine") ;
else table [hauteur++] = valeur ;}
public int removeValue () throws PileException{
if (hauteur == 0) throw new PileException ("Pile vide") ;
else return table [--hauteur] ;}}
class PileException extends Exception{

PileException(String m){super (m) ;}}
Class test{
Public static void main(String [] args){
Pile pile = new Pile () ;
try {
System.out.println (pile.removeValue()) ;
} catch (PileException e)
{
System.out.println (e.getMessage()) ;
}}
Exemple 2
class Point{
public Point(int x, int y) throws ErrConst
{ if ( (x<0) || (y<0)) throw new ErrConst() ;
this.x = x ; this.y = y ; }
public void deplace (int dx, int dy) throws ErrDepl
{ if ( ((x+dx)<0) || ((y+dy)<0)) throw new ErrDepl() ;
x += dx ; y += dy ;
}
public void affiche()
{ System.out.println ("coordonnees : " + x + " " + y) ; }
private int x, y ;
}
class ErrConst extends Exception
{}
class ErrDepl extends Exception
{}
public class Except2

{ public static void main (String args[])
{ try
{ Point a = new Point (1, 4) ;
a.affiche() ;
a.deplace (-3, 5) ;
a = new Point (-3, 5) ;
a.affiche() ;
}
catch (ErrConst e)
{ System.out.println ("Erreur construction ") ;
System.exit (-1) ; }
catch (ErrDepl e)
{ System.out.println ("Erreur deplacement ") ;
System.exit (-1) ;
}}}
Exemple 3
class Point
{ public Point(int x, int y) throws ErrConst
{ if ( (x<0) || (y<0)) throw new ErrConst() ;
this.x = x ; this.y = y ;
}
private int x, y ;
}
class ErrConst extends Exception
{}
public class test

{ try
{ System.out.println ("debut bloc try du main") ;
System.out.print ("donnez un entier : ") ;
int n = Clavier.lireInt() ;
Point a = new Point (n, n) ;
System.out.println ("fin bloc try du main") ;
}
catch (ErrConst e)
{ System.out.println ("dans catch (ErrConst) de main") ;
}
finally
{ System.out.println ("execution du bloc finally") ;
}
System.out.println ("apres bloc try main") ;
}}
L'abstraction
Présentation
Une classe abstraite est une classe qui ne permet pas
d’instancier des objets.Elle ne peut servir que de classe de
base pour une dérivation.Elle se déclare ainsi:
abstract class Nom_de_la_classe
{
…
}
Dans une classe abstraite, on peut trouver classiquement

des méthode et des champs, dont héritera toute classe
dérivée.
Mais on peut aussi trouver des méthodes dites abstraites,
c-à-d on ne fournit que la signature et le type de la valeur
de retour.
Exemple
abstract class A
{
Public void f(){…..}
Public abstract void g(int n);
…}
Exemple (suite)
A a;
a = new A(…); //Erreur
En revanche, si on dérive de A une classe B qui définit
la méthode abstraite g:
Class B extends A{
Public void g(int n){…}
…
}
On pourra alors instancier un objet de type B
A a=new B(…); //OK
• Une classe est abstraite si aucun objet du programme

n'est instance de cette classe
• Une classe qui a une méthode abstraite est
nécessairement abstraite
• On ne peut pas construire une instance d'une classe
abstraite
• Une méthode abstraite doit obligatoirement être
public.
• Les classes qui dérivent d'une classe abstraite doivent
instancier toutes ses méthodes abstraites (sinon, elles
sont abstraites)
• Dans une méthode abstraite les nom d’arguments
muets doivent figurer.
• Une classe dérivée d’une classe non abstraite peut
être déclarer abstraite et/ou contenir des méthode
abstraites
Abstraction : Exemple 1
abstract class Affichable{
abstract public void affiche() ;}
class Entier extends Affichable{
public Entier (int n)
{ valeur = n ; }
{ System.out.println ("Je suis un entier de valeur " + valeur) ;
}
private int valeur ;
}
class Flottant extends Affichable

{ public Flottant (float x)
{ valeur = x ; }
{ System.out.println ("Je suis un flottant de valeur " + valeur) ; }
private float valeur ;
}
public class testabst

{ public static void main (String[] args)
{ Affichable [] tab ;
tab = new Affichable [3] ;
tab [0] = new Entier (25) ;
tab [1] = new Flottant (1.25f) ; ;
tab [2] = new Entier (42) ;
int i ;
for (i=0 ; i<3 ; i++)
tab[i].affiche() ;
}}
class Vehicule { class Voiture extends Vehicule{
abstract void demarrer(); void demarrer()
{…}
}
}
class Garagiste {
public static void garer(Vehicule vA) l'exécution, Java sait
{v.demarrer(); } que l'objet est une voiture
}
class Main {
public static void main(String args[]){
Voiture voiture = new Voiture();
Garagiste.garer(voiture); }
}
• La classe Vehicule possède une méthode
demarrer(), donc la compilation fonctionne.
abstract class Mot
{
abstract void mettreAuPluriel();
}
class Verbe extends Mot
{
void mettreAuPluriel()
{ // fait appel aux conjugaisons;}
}
class Nom extends Mot
{
void mettreAuPluriel()
{ // ajoute un "s" sauf exception;}
}
• Le traitement mettreAuPluriel() existe pour tous les
mots, mais il est spécifique à chaque type de mot
Traitement générique élémentaire

class Analyseur
{
public void mettreAuPluriel(Mot mot)
{
mot.mettreAuPluriel();
}
public static void main(String args[])
{
Verbe v = new Verbe(« manger »);
Analyseur an = new Analyseur();
an.mettreAuPluriel(v);
}
}
• On peut passer un paramètre de type Verbe à une méthode
qui attend un Mot.
• Syntaxiquement, le paramètre est un mot. Mais à
l’exécution, c'est un verbe qui est passé en paramètre.
Travaux Dirigés
Articles à vendre
Une société vend des articles de papeterie. Vous vous limiterez
aux articles suivants :
•stylos décrits par une référence, un nom ou descriptif (par
exemple "stylo noir B2"), une marque, un prix unitaire et une
couleur,
•ramettes de papier décrites par une référence, un nom, une
marque, un prix unitaire et le grammage du papier (par exemple,
80 g/m²).
De plus cette société peut vendre ces articles par lots. Vous
supposerez que les lots sont composés d'un certain nombre d'un
même type d'articles, par exemple un lot de 10 stylos noirs B2 de
la marque WaterTruc.
Un lot a une référence et une marque (celle de l'article).

Le nom du lot est déterminé par le nombre d'articles dont il est
composé ; par exemple "Lot de 10 stylo noir B2" (vous êtes
dispensé de mettre les noms au pluriel !).
Le prix du lot est déterminé par le prix unitaire de l'article multiplié
par le nombre d'articles, auquel est enlevé un certain pourcentage
qui dépend du lot.
Par exemple, si un lot de 10 stylos à 100 dh a un pourcentage de
réduction de 20 %, le prix du lot sera de 10 x 100 x (100 - 20) / 100
= 800 dh.
Le prix d'un lot sera calculé au moment où on demandera le prix du
lot ; il n'est pas fixé une fois pour toute et il change si le prix de
l'article qui compose le lot est modifié.
Ecrivez des classes pour représenter les différents articles en
respectant le schéma suivant:
Article (abstraite)
String reference
Protected Article(String reference)

public String getreference()
public abstract String getDescriptif()
public abstract double getPU()
public String getMarque()
public String toString()
ArticleUnitaire (abstraite)
Article (abstraite)
private String marque;
private double pu;
private String descriptif;
Protected ArticleUnitaire (String reference)
public ArticleUnitaire(String reference, String
descriptif, String marque, double pu)
public void setMarque(String marque)
public double getPU()
public void setPU(double pu)
public String getDescriptif()
public void setDescriptif(String descriptif)
Article (abstraite)
Lot
private Article article
private int nb
private int pourcentage
public Lot(String reference)
public Lot(String reference, Article article, int
nb, int pourcentage)
public double getPU()
public String getDescriptif()
ArticleUnitaire(abstraite) Article (abstraite)
Stylo
private String couleur;
public Stylo(String reference)
public Stylo(String reference, String descriptif,
String marque, double pu, String couleur)
public String getCouleur()
ArticleUnitaire(abstraite) Article (abstraite)
Ramette
private int grammage
public Ramette(String reference)
public Ramette(String reference, String
descriptif, String marque, double pu, int
grammage)
public int getGrammage()
Article (abstraite)
ArticleUnitaire(abstraite) Lot
Stylo Ramette
public abstract class Article {

private String reference;
protected Article(String reference) { this.reference = reference; }
public String getReference() { return reference; }
public abstract String getDescriptif();
public abstract double getPU();
public String getMarque() { return "Sans marque"; }
public String toString() {
return this.getClass().getName() + ":reference="
+ reference + ";descriptif=" + getDescriptif()
+ ";marque=" + getMarque() + ";PU=" + getPU();}}
public abstract class ArticleUnitaire extends Article {

private String marque;
private double pu;
private String descriptif;
public ArticleUnitaire(String reference) { super(reference); }
public ArticleUnitaire(String reference, String descriptif,
String marque, double pu) {
super(reference);
this.marque = marque;
this.pu = pu;
this.descriptif = descriptif; }
public String getMarque() { return marque; }

public void setMarque(String marque) { this.marque =
marque; }
public double getPU() {return pu;}
public void setPU(double pu) { this.pu = pu; }
public void setDescriptif(String descriptif) {
this.descriptif = descriptif; }
public String getDescriptif() { return descriptif; }}
public class Lot extends Article {

private Article article;
private int nb, pourcentage;
public Lot(String reference) { super(reference); }
public Lot(String reference, Article article, int nb, int
pourcentage) { super(reference);
this.article = article;
this.nb = nb;
this.pourcentage = pourcentage; }
public double getPU() {
return nb * article.getPU() * (100 - pourcentage) / 100; }
public String getDescriptif() {

return "Lot de " + nb + " *" + article.getDescriptif() + "*
"; }
public String getMarque() { return article.getMarque(); }
return super.toString() + ";%réduction=" + pourcentage
+ ";composé de " + nb + " [" + article + "]";
}}
public class Stylo extends ArticleUnitaire {

private String couleur;
public Stylo(String reference) { super(reference); }
public Stylo(String reference, String descriptif, String marque,
double pu, String couleur) {
super(reference, descriptif, marque, pu);
this.couleur = couleur;
}
public String getCouleur() { return couleur; }
return super.toString() + ";couleur=" + couleur; }}
public class Ramette extends ArticleUnitaire {

private int grammage;
public Ramette(String reference) { super(reference); }
public Ramette(String reference, String descriptif, String
marque,
double pu, int grammage) {
super(reference, descriptif, marque, pu);
this.grammage = grammage;
}
public int getGrammage() { return grammage; }
return super.toString() + ";grammage=" + grammage; }}
Devoir pratique à rendre sur cd-Rom
La société établit des factures numérotées (en partant de 1) et datées,

comprenant le nom du client, le prix total de la commande et, pour
chaque article commandé, sa référence, son prix unitaire, le nombre
d'articles commandés et le prix total pour cet article.
Pour simplifier, un client ne sera qu'un simple nom dans la facture
(pas de classe Client).
Ajoutez les classes pour représenter ces factures
Vous écrirez une classe test qui affiche 1 facture pour
•10 stylos (choisissez ses caractéristiques)
•15 ramettes de papier
•2 lots de 5 stylos (différents des 10 stylos)
et une autre facture pour
•3 stylos
•2 ramettes
pour 2 clients différents.

Le programme créera tous les objets nécessaires à l'affichage des 2
factures.
Une facture s'affichera sur le modèle suivant (on ne demande pas
d'affiner davantage le format d'affichage mais si vous pouvez faire
mieux, n'hésitez pas !) :
---------------------------------------------------------------------
Facture 125 Client: Toto Date: 10 novembre 1999
Quant. Ref. Nom Marque PU PT
10 s1 Stylo Jade Watertruc 500.0 5000.0
15 r1 Ramette haute qualité Clairefont 95.0 1425.0
2 l1 Lot de 5 Stylo or Marker 4500.0 9000.0
Prix total facture : 15425.0 F
---------------------------------------------------------------------
Le Polymorphisme
Héritage et traitements
• L'héritage permet d'organiser les données sous
forme de classes de façon à coller à la
sémantique du domaine modélisé
• Mais l'héritage permet aussi d'organiser les
traitements de façon à éviter les répétitions de
code
• Pour utiliser correctement l’héritage, il faut de
l'abstraction et du polymorphisme
Le polymorphisme
• On appelle polymorphisme le fait qu'un objet d'une
classe puisse être manipulé comme s'il appartenait à
une autre classe
• Distinguer :
– le vrai type de l'objet : celui qui lui est donné lors de
l'appel du constructeur
– le type mentionné dans le code source
• Java peut convertir dynamiquement tout objet d'une
classe en un objet d'une classe plus générique ou
plus spécifique
• On dit que Java dispose d’un mécanisme de typage
dynamique
Polymorphisme : exemple (1)

void demarrer() void demarrer()
{…} {…}
} }
class Garagiste {
public static void garer(Vehicule v)
{v.demarrer(); } Méthode appelée ici
}
class Main {
}
• Bien que, syntaxiquement, v soit un véhicule, l'objet
est une voiture
Polymorphisme : exemple (2)

} void demarrer() {…}
class Garagiste { }
{v.demarrer(); } Ne compile pas !!!
}
class Main {
}
• Javac vérifie syntaxiquement que la classe
mentionnée possède bien la méthode
Polymorphisme implicite :
synthèse
• Java est capable de retrouver le vrai type de l'objet
même si ce n'est pas le type spécifié dans le code
source
• Si l'objet passé en paramètre (Vehicule v) est une
Voiture, il appellera la méthode demarrer() de la
classe Voiture
• Il suffit que Voiture hérite de Vehicule
• Si la méthode appelée existe pour les deux types,
alors Java appellera celle du vrai type de l'objet
même si le type mentionné est différent
• Si la méthode appelée n'existe pas pour le type
spécifié, alors Java refuse de compiler
Exemple de polymorphisme
class Point
{ public Point (int x, int y)
{ this.x = x ; this.y = y ; }
public void deplace (int dx, int dy)
{ x += dx ; y += dy ; }
public void affiche ()
{ System.out.println ("Je suis en " + x + " " + y) ; }
protected int x, y ;
}
class Pointcol extends Point
{ public Pointcol (int x, int y, byte couleur)
{ super (x, y) ; this.couleur = couleur ; }
{ super.affiche() ;
System.out.println (" et ma couleur est : " + couleur) ; }
private byte couleur ;}
public class Poly

{ Point p = new Point (3, 5) ;
p.affiche() ; // appelle affiche de Point
Pointcol pc = new Pointcol (4, 8, (byte)2) ;
p = pc ; // p de type Point, référence un objet de type Pointcol
p.affiche() ; // on appelle affiche de Pointcol
p = new Point (5, 7) ; // p référence a nouveau un objet de type
Point
p.affiche() ; // on appelle affiche de Point
}}
Exemple d’utilisation
du polymorphisme pour gerer
un tableau heterogene
class Point
private int x, y ;
}
{ super (x, y) ; // obligatoirement comme première instruction
this.couleur = couleur ; }
{ super.affiche() ;
System.out.println (" et ma couleur est : " + couleur) ; }
private byte couleur ;}
public class TabHeter

{ Point [] tabPts = new Point [4] ;
tabPts [0] = new Point (0, 2) ;
tabPts [1] = new Pointcol (1, 5, (byte)3) ;
for (int i=0 ; i< tabPts.length ; i++)
tabPts[i].affiche() ;
}
}
Une autre situation ou le

polymorphisme
se revele indispensable
class Point
{ identifie() ;
System.out.println (" Mes coordonnees sont : " + x + " " + y) ;
}
public void identifie ()
{ System.out.println ("Je suis un point ") ; }
private int x, y ;
}
{ super (x, y) ;
this.couleur = couleur ; }
public void identifie ()
{ System.out.println ("Je suis un point colore de couleur " + couleur) ; }
private byte couleur ;
public class TabHet2

{ Point [] tabPts = new Point [4] ;
for (int i=0 ; i< tabPts.length ; i++)
tabPts[i].affiche() ; }}
Polymorphisme explicite
• Si l’on veut appeler une méthode qui n'existe que
pour le type spécifique, alors il faut << caster >>,
c'est à dire déclarer le type spécifique de l'objet
• Le << cast >> est utile à la compilation : permet à
Java de connaître le vrai type, donc de savoir quelle
est la méthode spécifique qui sera appelée
• Si l'on << caste >> alors que l'objet n'est pas du type
casté, Java lève à l'exécution l'exception :
ClassCastException
Polymorphisme explicite :
exemple (1)
} void demarrer()
class Garagiste { {…}
public static void garer(Vehicule v) }
{((Voiture)v).demarrer(); } Java sait que l'objet sera
} une voiture
class Main {
}
• Problème : la méthode garer(Vehicule v) n'est plus
générique, elle ne marche que pour les voitures
exemple (2)
} void demarrer(){…}
class Garagiste { }
{((Voiture)v).demarrer(); } ClassCastException à
} l'exécution
class Main {
Camion cam = new Camion();
Garagiste.garer(cam); }
}
• Solution éventuelle : vérifier le type de l'objet
exemple (3)
} void demarrer(){…}
}
class Garagiste {
{ if (v instanceof Voiture)
((Voiture)v).demarrer();
else if (v instanceof Camion)
((Camion)v).demarrer(); // …
}
}
• Problème : il faut connaître la liste des types
possibles
Connaître le type d'un objet

• if (v instanceof Vehicule) vérifie si v est un pointeur
sur un objet de type Vehicule ou bien tout type plus
spécifique que Vehicule
– Si v est un Camion, renvoie <<true>>
• if (v.getClass().getName().equals("Vehicule"))
vérifie si v est un pointeur sur un objet de type
Vehicule.
– Si v est un Camion, renvoie <<false>>
– Cette deuxième méthode fait appel à la réflexivité (quel
est le nom de la classe de l'objet ?)
Utilisation d’une reference de type Object
Point P = new Point(12,8);

Object O;
O=P;
O.deplace();\\Erreur de compilation
((Point)O).deplace();
Point p1=(Point)o;
P1.deplace();
Les collections
• Les collections sont des objets qui

permettent de gérer des ensembles
d'objets.
• Ces ensembles de données peuvent être
définis avec plusieurs caractéristiques :
• la possibilité de gérer des doublons, de
gérer un ordre de tri, etc. ...
• Chaque objet contenu dans une
collection est appelé un élément.
Présentation du framework
collection
• Dans la version 1 du J.D.K., il n'existe qu'un
nombre restreint de classes pour gérer des
ensembles de données :
• · Vector
• · Stack
• · Hashtable
• · Bitset
• L'interface Enumeration permet de parcourir le
contenu de ces objets.
Les interfaces à utiliser par des objets qui gèrent des

collections sont :
• Collection : interface qui est implementée par la
plupart des objets qui gèrent des collections
• Map : interface qui définit des méthodes pour des
objets qui gèrent des collections sous la forme
clé/valeur
• Set : interface pour des objets qui n'autorisent pas
la gestion des doublons dans l'ensemble
• List : interface pour des objets qui autorisent la
gestion des doublons et un accès direct à un
élément
• SortedSet : interface qui étend l'interface Set et
permet d'ordonner l'ensemble
• SortedMap : interface qui étend l'interface Map et
permet d'ordonner l'ensemble
Le framework propose plusieurs objets qui

implémentent ces interfaces et qui peuvent être
directement utilisés :
•HashSet : HashTable qui implémente l'interface Set
•TreeSet : arbre qui implémente l'interface SortedSet
•ArrayList : tableau dynamique qui implémente
l'interface List
•LinkedList : liste doublement chaînée (parcours de la
liste dans les deux sens) qui implémente l'interface
List
•HashMap : HashTable qui implémente l'interface
Map
•TreeMap : arbre qui implémente l'interface
SortedMap
Le framework définit aussi des interfaces pour faciliter le

parcours des collections et leur tri :
•Iterator : interface pour le parcours des collections
•ListIterator : interface pour le parcours des listes dans les
deux sens et modifier les éléments lors de ce parcours
•Comparable : interface pour définir un ordre de tri naturel
pour un objet
•Comparator : interface pour définir un ordre de tri
quelconque
Deux classes existantes dans les précédentes versions du JDK
ont été modifiées pour implémenter certaines interfaces du
framework :
•Vector : tableau à taille variable qui implémente maintenant
l'interface List
•HashTable : table de hashage qui implémente maintenant
l'interface Map
Les interfaces des collections

• Le framework de java 2 définit 6 interfaces
en relation directe avec les collections qui
sont regroupées dans deux arborescences :
• Le JDK ne fourni pas de classes qui implémentent

directement l'interface Collection.
• Le tableau ci dessous présente les différentes classes
qui implémentent les interfaces de bases Set, List et
Map :
L'interface Collection
• Cette interface définit des méthodes pour des
objets qui gèrent des éléments d'une façon assez
générale.
• Elle est la super interface de plusieurs interfaces
du framework.
• Plusieurs classes qui gèrent une collection
implémentent une interface qui hérite de l'interface
Collection.
• Cette interface est une des deux racines de
l'arborescence des collections.
• Cette interface définit plusieurs méthodes :
L'interface Iterator
• Cette interface définit des méthodes pour
des objets capables de parcourir les données
d'une collection.
Exemples
Iterator iterator = collection.Iterator();
while (iterator.hasNext()) {
System.out.println(“objet = ”+iterator.next());
}
Iterator iterator = collection.Iterator();
if (iterator.hasNext()) {
iterator.next();
itérator.remove();
}
Si aucun appel à la méthode next() ne correspond à
celui de la méthode remove(), une exception de type
IllegalStateException est levée
Les listes
• Une liste est une collection ordonnée
d'éléments qui autorise d'avoir des
doublons.
• Etant ordonnée, un élément d'une liste peut
être accédé à partir de son index.
L'interface List
• Cette interface étend l'interface Collection.
• Les collections qui implémentent cette interface
autorisent les doublons dans les éléments de la
liste.
• Ils autorisent aussi l'insertion d'éléments null.
• L'interface List propose plusieurs méthodes pour
un accès à partir d'un index aux éléments de la
liste. La gestion de cet index commence à zéro.
• Pour les listes, une interface particulière est
définie pour assurer le parcours dans les deux sens
de la liste et assurer des mises à jour : l'interface
ListIterator
Les listes chaînées : la

classe LinkedList
• Cette classe hérite de la classe
AbstractSequentialList et implémente donc
l'interface List.
• Elle représente une liste doublement chaînée.
• Cette classe possède un constructeur sans
paramètre et un qui demande une collection. Dans
ce dernier cas, la liste sera initialisée avec les
éléments de la collection fournie en paramètre..
import java.util.*;
public class ListExemple {
public static void main(String args[]) {
List list = new ArrayList();
list.add("ALI");
list.add("MOHAMED");
list.add("SARA");
list.add("ILHAM");
list.add("NAWAL");
System.out.println(list);
System.out.println("2: " + list.get(2));
System.out.println("0: " + list.get(0));
LinkedList queue = new LinkedList();

queue.addFirst("Bernadine");
queue.addFirst("Elisabeth");
queue.addFirst("Gene");
queue.addFirst("Elisabeth");
queue.addFirst("Clara");
System.out.println(queue);
queue.removeLast();
queue.removeLast();
System.out.println(queue);
}}
Une liste chaînée gère une collection de façon

ordonnée : l'ajout d'un élément peut se faire à
la fin de la collection ou
après n'importe quel élément. Dans ce cas,
l'ajout est lié à la position courante lors d'un
parcours.
Pour répondre à ce besoin, l'interface qui
permet le parcours de la collection est une sous
classe de l'interface Iterator :
l'interface ListIterator.
• Comme les iterator sont utilisés pour faire des

mises à jour dans la liste, une exception de type
CurrentModificationException levé si un iterator
parcours la liste alors qu'un autre fait des mises à
jour (ajout ou suppression d'un élément dans la
liste).
• Pour gérer facilement cette situation, il est
préférable si l'on sait qu'il y ait des mises à jour à
faire de n'avoir qu'un seul iterator qui soit utilisé.
• Plusieurs méthodes pour ajouter, supprimer ou
obtenir le premier ou le dernier élément de la liste
permettent d'utiliser cette classe pour gérer une
pile :
L'interface ListIterator
• Cette interface définit des méthodes pour parcourir
la liste dans les deux sens et effectuer des mises à
jour qui agissent par rapport à l'élément courant dans
le parcours.
• En plus des méthodes définies dans l'interface
Iterator dont elle hérite, elle définit les méthodes
suivantes :
Les tableaux redimensionnables

la classe ArrayList
• Cette classe représente un tableau d'objets dont la taille est
dynamique.
• Elle hérite de la classe AbstractList donc elle implémente
l'interface List.
• Le fonctionnement de cette classe est identique à celui de la
classe Vector.
• La différence avec la classe Vector est que cette dernière est
multi thread (toutes ces méthodes sont synchronisées).
• Pour une utilisation dans un thread unique, la
synchronisation des méthodes est inutile et coûteuse. Il est
alors préférable d'utiliser un objet de la classe ArrayList.
• Elle définit plusieurs méthodes dont les principales sont :
Les ensembles
• Un ensemble (Set) est une collection qui
n'autorise pas l'insertion de doublons.
L'interface Set
• Cette classe définit les méthodes d'une collection qui
n'accepte pas de doublons dans ces éléments. Elle hérite de
• l'interface Collection mais elle ne définie pas de nouvelle
méthode.
• Pour déterminer si un élément est déjà inséré dans la
collection, la méthode equals() est utilisée.
• Le framework propose deux classes qui implémentent
l'interface Set : TreeSet et HashSet
• Le choix entre ces deux objets est liés à la nécessité de trié
les éléments :
• · les éléments d'un objet HashSet ne sont pas triés :
l'insertion d'un nouvel élément est rapide
• · les éléments d'un objet TreeSet sont triés : l'insertion d'un
nouvel éléments est plus long
L'interface SortedSet
• Cette interface définit une collection de type
ensemble triée. Elle hérite de l'interface Set.
• Le tri de l'ensemble peut être assuré par deux
façons :
• · les éléments contenus dans l'ensemble
implémentent l'interface Comparable pour définir
leur ordre naturel
• · il faut fournir au constructeur de l'ensemble un
objet Comparator qui définit l'ordre de tri à utiliser
• Elle définit plusieurs méthodes pour tirer parti de
cette ordre :
La classe HashSet
• Cette classe est un ensemble sans ordre de
tri particulier.
• Les éléments sont stockés dans une table de
hashage : cette table possède une capacité.
Exemples
import java.util.*;
public class TestHashSet {
Set set = new HashSet();
set.add("CCCCC");
set.add("BBBBB");
set.add("DDDDD");
set.add("BBBBB");
set.add("AAAAA");
Iterator iterator = set.iterator();
while (iterator.hasNext())
{System.out.println(iterator.next());}}}
La classe TreeSet
• Cette classe est un arbre qui représente un ensemble trié
d'éléments.
• Cette classe permet d'insérer des éléments dans n'importe
quel ordre et de restituer ces éléments dans un ordre précis
lors de son parcours.
• L'implémentation de cette classe insère un nouvel élément
dans l'arbre à la position correspondant à celle déterminée
par l'ordre de tri.
• L'insertion d'un nouvel élément dans un objet de la classe
TreeSet est donc plus lent mais le tri est directement
effectué.
• L'ordre utilisé est celui indiqué par les objets insérés si ils
implémentent l'interface Comparable pour un ordre de tri
• naturel ou fournir un objet de type Comparator au
constructeur de l'objet TreeSet pour définir l'ordre de tri.
Exemple
import java.util.*;
public class TestTreeSet {
Set set = new TreeSet();
set.add("CCCCC");
set.add("BBBBB");
set.add("DDDDD");
set.add("BBBBB");
set.add("AAAAA");
Iterator iterator = set.iterator();
while (iterator.hasNext())
{System.out.println(iterator.next());}}}
Les collections gérées sous la

forme clé/valeur
• Ce type de collection gère les éléments avec deux
entités : une clé et une valeur associée.
• La clé doit être unique donc il ne peut y avoir de
doublons. En revanche la même valeur peut être
associées à plusieurs clés différentes.
• Avant l'apparition du framework collections, la
classe dédiée à cette gestion était la classe
Hashtable.
L'interface Map
• Cette interface est une des deux racines de
l'arborescence des collections.
• Les collections qui implémentent cette
interface ne peuvent contenir des doublons.
Les collections qui implémentent cette
interface utilise une association entre une
clé et une valeur.
• Elle définit plusieurs méthodes pour agir sur
la collection :
L'interface SortedMap
• Cette interface définit une collection de type Map
triée sur la clé. Elle hérite de l'interface Map.
• Le tri peut être assuré par deux façons :
• · les clés contenues dans la collection
implémentent l'interface Comparable pour définir
leur ordre naturel
• · il faut fournir au constructeur de la collection un
objet Comparator qui définit l'ordre de tri à utiliser
• Elle définit plusieurs méthodes pour tirer parti de
cette ordre :
La classe Hashtable
• Cette classe qui existe depuis le premier jdk
implémente une table de hachage.
• La clé et la valeur de chaque élément de la
collection peut être n'importe quel objet non nul.
• A partir de Java 1.2 cette classe implémente
l'interface Map.
• Une des particularités de classe HashTable est
quelle est synchronisée.
import java.util.*;
public class TestHashtable {
public static void main(String[] args) {
Hashtable htable = new Hashtable();
htable.put(new Integer(3), "données
3");
1");
2");
System.out.println(htable.get(new
La classe TreeMap
• Cette classe gère une collection d'objets sous la
forme clé/valeur stockés dans un arbre de type
rouge?noir (Red?black tree).
• Elle implémente l'interface SortedMap. L'ordre
des éléments de la collection est maintenu grace à
un objet de type Comparable.
• Elle possède plusieurs constructeurs dont un qui
permet de préciser l'objet Comparable pour définir
l'ordre dans la collection.
Exemple
import java.util.*;
public class TestTreeMap {
public static void main(String[] args) {
TreeMap arbre = new TreeMap();
arbre.put(new Integer(3), "données 3");
Set cles = arbre.keySet();
Iterator iterator = cles.iterator();
while (iterator.hasNext()) {
System.out.println(arbre.get(iterator.next()));
}}}
La classe HashMap
• La classe HashMap est similaire à la classe
Hashtable. Les trois grandes différences sont :
• · elle est apparue dans le JDK 1.2
• · elle n'est pas synchronisée
• · elle autorise les objets null comme clé ou valeur
• Cette classe n'étant pas synchonisée, pour assurer
la gestion des accès concurents sur cet objet, il
faut l'envelopper dans un objet Map en tulisant la
méthode synchronizedMap de la classe Collection.
Le tri des collections
• L'ordre de tri est défini grace à deux

interfaces :
• · Comparable
• · Comparator
L'interface Comparable
• Tous les objets qui doivent définir un ordre naturel utilisé
par le tri d'une collection avec cet ordre doivent
implémenter cette interface.
• Cette interface ne définit qu'une seule méthode : int
compareTo(Object).
• Cette méthode doit renvoyer :
• · une valeur entière négative si l'objet courant est inférieur à
l'objet fourni
• · une valeur entière positive si l'objet courant est supérieur à
l'objet fourni
• · une valeur nulle si l'objet courant est égal à l'objet fourni
• Les classes wrappers, String et Date implémentent cette
interface.
L'interface Comparator
• Cette interface représente un ordre de tri quelconque. Elle
est utile pour permettre le tri d'objet qui n'implémente pas
l'interface Comparable ou pour définir un ordre de tri
différent de celui défini avec Comparable ( l'interface
Comparable représente un ordre naturel : il ne peut y en
avoir qu'un)
• Cette interface ne définit qu'une seule méthode : int
compare(Object, Object).
• Cette méthode compare les deux objets fournis en paramètre
et renvoie :
• · une valeur entière négative si le premier objet est inférieur
au second
• · une valeur entière positive si le premier objet est supérieur
au second
• · une valeur nulle si les deux objets sont égaux
• La classe Collections propose plusieurs

méthodes statiques qui effectuer des
opérations sur des collections.
• Ces traitements sont polymorphiques car ils
demandent en paramètre un objet qui
implémente une interface et retourne une
collection.
Exemple
import java.util.*;
public class TestUnmodifiable{
{
List list = new LinkedList();
list.add("1");
list.add("2");
list = Collections.unmodifiableList(list);
list.add("3");
}}
• L'utilisation d'une méthode

synchronizedXXX() renvoie une instance
de l'objet qui supporte la synchronisation
pour les opérations d'ajout et de suppression
d'éléments. Pour le parcours de la collection
avec un objet Iterator, il est nécessaire de
synchroniser le bloc de code utilisé pour le
parcours.
• Il est important d'inclure aussi dans ce bloc
l'appel à la méthode pour obtenir l'objet de
type Iterator utilisé pour le parcours.
import java.util.*;
public class TestSynchronized{
{
List maList = new LinkedList();
maList.add("1");
maList.add("2");
maList.add("3");
maList = Collections.synchronizedList(maList);
synchronized(maList) {
Iterator i = maList.iterator();
while (i.hasNext())
System.out.println(i.next());}}}
Les exceptions du
framework
• L'exception de type
UnsupportedOperationException est levée lorsque
qu'une opération optionnelle n'est pas supportée
par l'objet qui gère la collection.
• L'exception ConcurrentModificationException est
levée lors du parcours d'une collection avec un
objet Iterator et que cette collection subi une
modification structurelle.
L'héritage
Un cas concret
• La classe Voiture représente toutes sortes de
voitures possibles
• On pourrait définir un camion comme une voiture
très longue, très haute, etc.
• Mais un camion a des spécificités vis-à-vis des
voitures : remorque, cargaison, boîte noire, etc.
• On pourrait créer une classe Camion qui ressemble
à la classe Voiture
• Mais on ne veut pas réécrire tout ce qu'elles ont en
commun
Solution
Vehicule
Voiture Camion
• La classe Vehicule contient tout ce qu'il y a de

commun à Camion et Voiture
• Camion ne contient que ce qu'il y a de spécifique
aux camions
Objectif de l'héritage
• On souhaite ne décrire qu'une seule fois le même
traitement lorsqu'il s'applique à plusieurs classes
• Evite de recopier (notamment les modifications)
• On crée une classe plus générique à laquelle
s'applique le traitement
• Toutes les classes plus spécifiques, héritant de cette
classe, héritent de ce traitement, elles peuvent
l'exécuter
• Le traitement n'est décrit qu'au niveau de la classe
mère
Usage de l'héritage
• Une classe spécifique hérite des méthodes et des
attributs de sa classe mère (sauf ceux qui sont
privés)
• On n'a pas besoin de les réécrire pour la classe fille
• On peut cependant redéfinir une méthode de la
classe mère dans la classe fille (de même signature)
• Le constructeur d'un objet doit toujours commencer
par appeler le constructeur de sa classe mère
Usage de l'héritage (suite)

• Un objet de type Voiture peut utiliser toutes les
méthodes de la classe Vehicule
• Il doit disposer d’une valeur pour tous les attributs
de la classe Vehicule
• A tout moment, une méthode qui utilise un objet
de type Vehicule peut manipuler un objet de type
Voiture en guise de Vehicule
• Cette dernière propriété est le polymorphisme.
héritage : Exemple 1
class Vehicule {
// Vehicule() {}
}
class Voiture extends Vehicule {

int nbPortes;
double longueur;
Voiture(double lg, int nbP)
{
longueur = lg;
nbPortes = nbP;
}
}
Exemple 1 : suite
class Garagiste {
public boolean garer(Vehicule v)
{
v.demarrer();
for (int pl=0;pl<nbPlaces;++pl)
{
if (place[pl].estLibre())
{
v.amener(place[pl]);
v.arreter();
return true;
}
}
System.out.println(« Aucune place libre »);
return false;
}
}
On peut appliquer la méthode garer() à une Voiture, un Camion…
// classe de base Exemple 2 :

class Point
// classe utilisant Pointcol
{ public void initialise (int abs, int ord)
public class TstPcol1
{ x = abs ; y = ord ;
{ public static void main (String
} args[])
public void deplace (int dx, int dy) {
{ x += dx ; y += dy ; Pointcol pc = new Pointcol() ;
} pc.affiche() ;
public void affiche () pc.initialise (3, 5) ;
{ pc.colore ((byte)3) ;
System.out.println ("Je suis en " + x + " " + y) ; pc.affiche() ;
} pc.deplace (2, -1) ;
protected int x, y ; pc.affiche() ;
} Point p = new Point() ;
// classe derivee de Point p.initialise (6, 9) ;
class Pointcol extends Point p.affiche() ;
{ public void colore (byte couleur) }
{ this.couleur = couleur ; }
}
}
Accès d’une classe dérivée aux

membres de sa classe de base
• Une méthode d’une classe dérivée n’a pas
accès aux membres privés de sa classe de
base.
• Une méthode d’une classe dérivée a accès
aux membres public de sa classe de base.
// classe de base
class Point
{ x = abs ; y = ord ; }
{ x += dx ; y += dy ; }
}
// classe derivee de Point

{ public void colore (byte couleur)
{ this.couleur = couleur ;
}
public void affichec ()
{ affiche() ;
System.out.println (" et ma couleur est : " + couleur) ;
}
public void initialisec (int x, int y, byte couleur)
{ initialise (x, y) ;
this.couleur = couleur ;
}
}
// classe utilisant Pointcol

{ Pointcol pc1 = new Pointcol() ;
pc1.initialise (3, 5) ;
pc1.colore ((byte)3) ;
pc1.affiche() ; // attention, ici affiche
pc1.affichec() ; // et ici affichec
Pointcol pc2 = new Pointcol() ;
pc2.initialisec(5, 8, (byte)2) ;
pc2.affichec() ;
pc2.deplace (1, -3) ;
pc2.affichec() ;
}}
Construction et
initialisation des objets
dérivés
super() et super
La méthode super()
• super() permet d'appeler le constructeur de la
classe mère
• C'est la première chose à faire dans la construction
d'une sous-classe
• Appeler le constructeur de la classe mère garantit
que l’on peut initialiser les arguments de la classe
mère
• On passe les paramètres nécessaires
• Si l’on n’indique pas super(), appel du
constructeur par défaut de la classe mère
class Point
super() : Exemple
{ this.x = x ; this.y = y ;
}
{ x += dx ; y += dy ;
}
{ System.out.println ("Je suis en " + x + " " + y) ;
}
}
{ super (x, y) ; // obligatoirement comme première instruction
this.couleur = couleur ;
}
public void affichec ()
{ affiche() ;
System.out.println (" et ma couleur est : " + couleur) ;
}
}
super() : Exemple(suite)
{ Pointcol pc1 = new Pointcol(3, 5, (byte)3) ;
pc1.affiche() ; // attention, ici affiche
pc1.affichec() ; // et ici affichec
Pointcol pc2 = new Pointcol(5, 8, (byte)2) ;

pc2.affichec() ;
pc2.deplace (1, -3) ;
pc2.affichec() ;
}
}
Le mot clef super

• super. est une référence sur l'objet père
• super.maMethode() permet d'appeler la méthode
maMethode() de la classe mère
• Le constructeur de la classe dérivée doit prendre
en charge l’intégralité de la construction de
l’objets.
• Si un constructeur d’une classe dérivée appelle un
constructeur d’une classe de base, il doit
obligatoirement s’agir de la première instruction
du constructeur et ce dernier est désigné par le
méthode super .
Héritage
et appel de méthodes
Appel de méthodes : synthèse (1)

{…} {…}
} }
class Main { Méthode appelée ici

Voiture v = new Voiture();
v.demarrer();
}
}
• Java commence par chercher la méthode dans la

classe de l'objet créé

void demarrer() }
{…}
}

v.demarrer();
}
}
• Si la méthode n'existe pas dans la classe de l'objet
créé, il va chercher dans la classe mère

{…} {…}
} }

v.super.demarrer();
}
}
• Pour appeler directement la méthode de la classe
mère, utiliser le mot clef super.
Héritage et visibilité
Héritage et visibilité
• Une classe fille hérite des attributs et
méthodes public et protected de la classe mère
• Elle n’hérite pas des attributs et méthodes
private
• La classe mère ne voit que ce qui est public
dans la classe fille
• Un objet d’une classe mère n’hérite pas des
attributs et méthodes de ses classes filles
visibilité : exemple
class Vehicule {
protected double longueur;
}
class Voiture extends Vehicule {

protected int nbPortes;
…
}
• On peut utiliser l’attribut longueur dans Vehicule et dans

Voiture
• On ne peut pas utiliser l’attribut nbPortes dans la classe
Vehicule
Surcharge (rappel)
• On appelle surcharge le fait d’avoir plusieurs
méthodes qui ont le même nom au sein de la
même classe
• Les exemplaires de la méthode ont des
paramètres différents
• Ils peuvent avoir le même type de retour
• Par contre, impossible d’avoir des types de
retour différents pour les mêmes paramètres
Surcharge : exemple
class Additionneur {
static int somme(int a, int b)
{
return (a+b);
}
static int somme(int a, int b, int c)
{
return (a+b+c);
}
}
• Les deux méthodes somme(…) appartiennent à la

même classe mais n'ont pas la même signature => il
s'agit de surcharge
Redéfinition
• On appelle redéfinition d’une méthode le fait
de définir dans une classe fille une méthode
qui a le même nom, les mêmes paramètres et
le même type de retour qu’une méthode de la
classe mère
• La méthode redéfinie « masque » celle de la
classe mère
• Ne pas confondre avec surcharge : paramètres
différents
Redéfinition : exemple
class Personne{
void garer(Vehicule v)
{
v.demarrer();
//…
}
}
class Garagiste extends Personne{

{
v.fermerCapot(); // appelle getCapot().fermer()
v.demarrer();
//…
}
• Les deux méthodes ont la même signature et
appartiennent à deux classes liées par héritage => il
s'agit de redéfinition
Surcharge ou redéfinition ?
class Personne{
{
v.demarrer();
//…
}
}
class Garagiste extends Personne{

void garer(Voiture v)
{
v.fermerCapot(); // appelle getCapot().fermer()
v.demarrer();
//…
}
Redéfinition et Surcharge
• Quand il y a des paramètres différents, mais
qui héritent les uns des autres…
• Ils sont vus comme effectivement différents
• C’est donc un cas de surcharge
• La méthode appelée sera celle dont les
paramètres sont du type le plus spécialisé qui
correspondent au type d’appel
• Le choix est fait à la compilation
Exemple de problèmes (1)

class Voiture { class VoitureDiesel extends Voiture {
public boolean equals(Voiture v2) public boolean equals(VoitureDiesel v2)
{…} {…}
} }
class Garagiste{
Vector mesVoitures;
public comparerToutes(Voiture v2)

{
for (int i=0;i<mesVoitures.size();++i)
{
if ((Voiture)mesVoitures[i]).equals(v2)) {…}
}
}
}
• Quelle est la méthode appelée si mesVoitures[i] est
une VoitureDiesel et v2 aussi ?
Exemple de problèmes (2)

class Voiture { class VoitureDiesel extends Voiture {
public boolean equals(Voiture v2) public boolean equals(VoitureDiesel v2)
{…} {…}
} }
• C'est un cas de surcharge, qui revient à
class VoitureDiesel extends Voiture {
public boolean equals(Voiture v2)
{…}
public boolean equals(VoitureDiesel v2)
{…}
}
• C'est donc la première méthode qu'on appelle
• Du coup, on va comparer deux voitures et non pas
deux voitures diesel…
Solution (moche) au problème

class VoitureDiesel extends Voiture
{
public boolean equals(Voiture v2)
{
if (v2 instanceof VoitureDiesel) {…}
}
}
• On fait en sorte que la signature de la méthode soit la

même
• On encapsule les vérifications de type dans la
méthode
Le typage dynamique
Le typage dynamique (1)

• Il ne faut pas confondre :
– le type de la référence de l’objet (ce qui apparaît
dans le code)
– le type de l’objet effectivement utilisé (celui qui
est construit)
• Le premier est vérifié à la compilation
• Le second est vérifié à l’exécution.
• Il faut que les deux soient compatibles
Le typage dynamique (2)

• Les objets connaissent en permanence le type selon
lequel ils ont été créés
• Il peut donc y avoir différence entre le type de la
référence et celui de l’objet
• Exemple :
Point p = new PointCol();
System.out.println((p.getClass()).getName());
=> Affiche PointCol et non pas Point
• Pour que l’on puisse compiler et exécuter, il faut que
le type effectif hérite du type déclaré
Exemple : une classe Point

class Point
{
int x,y;
Point(int a, int b){x=a; y=b;}
Point(){x=0; y=0;}
public void moveTo (int a, int b){x=a; y=b;}

public String toString(){return ‘(‘ + x + « , » + y + ‘)’);}
public void affiche(){System.out.println(toString());}
public void distanceToOrigin()
{
return Math.sqrt(x*x +y*y);
}
}
Exemple : classe PointCol (oré)

class PointCol extends Point
{
String couleur;
Point(int a, int b, String c){super(a,b);couleur=c;}
Point(){couleur=« blanc »;} // appel implicite de super()
public String getColor(){return couleur;}
{
return super.toString()+couleur;
}
}
Le typage dynamique : Exercice

• Quelles sont les expressions correctes ?
• Point p1 = new Point();
• Point p2 = new PointCol();
• PointCol pc1 = new PointCol();
• PointCol pc2 = new Point();
• p1.moveTo(1,2);
• pc1 = p2;
• pc1 = (PointCol) p2;
Solution
• Point p1 = new Point(); // OK
• Point p2 = new PointCol(); // OK
• PointCol pc1 = new PointCol(); // OK
• PointCol pc2 = new Point(); // erreur compilation
• p1.moveTo(1,2); // OK
• pc1 = p2; // erreur compilation (!)
• pc1 = (PointCol) p2; // OK (cast)
Exemples de synthèse
Cet exemple comporte trois classes :
• la classe Nom qui représente un nom de famille. Cette classe
comporte comme attribut une chaîne de caractères qui s'appelle
nom, un constructeur et une méthode qui retourne une chaîne de
caractères qui est l'inverse de nom.
• la classe Identite qui représente l'identité d'une personne.
Cette classe étend la classe Nom. Du point de vue de la syntaxe,
cela se lit sur l'en-tête de la classe Identite : class Identite
extends Nom
On dit aussi, et cela a la même signification, que la classe
Identite hérite de la classe Nom. On dit encore que la classe
Nom est la super-classe de la classe Identite. On dit enfin que la
classe Identite est une sous-classe de la classe Nom.
La conséquence de cette héritage est que l'attribut et la
méthodes de la classe Nom appartiennent aussi à la classe
Identite. On peut si on le veut ajouter des attributs et des
méthodes supplémentaires à la classe Identite. C'est ce qui est
fait ici avec l'attribut prenom et la méthode toString.
Les instances de la classe Identite sont aussi des instances de la
la classe Nom.
• la classe PremierHeritage qui instancie la classe Identite et l'utilise.
class Nom {
String nom;
Nom(String nom) { this.nom = nom; }
String renverseNom()
{ StringBuffer envers=new StringBuffer(nom);
for (int i=0;i< nom.length();i++)
envers.setCharAt(i,nom.charAt(nom.length() – i -1));
return envers.toString(); }
}
class Identite extends Nom {
String prenom;
Identite(String prenom, String nom)
{ super(nom);
this.prenom = prenom; }
return prenom+" "+nom; } }
class PremierHeritage { public static void main(String[]

argv)
{ Identite unePersonne = new Identite(argv[0], argv[1]);
System.out.println(unePersonne.toString());
System.out.println("Nom a l'envers : " +
unePersonne.renverseNom()); } }
Un exemple utilisant "super"

class Superieure {
int i=1;
void affiche() {
System.out.println("je suis en-haut"); } }
class Inferieure extends Superieure {
int i=2;
void affiche() {
super.affiche();
System.out.println("je suis en-bas");
System.out.println("au-dessus, i vaut "+super.i);
System.out.println("ici, i vaut "+i); } }
Un exemple utilisant "super"
class AvecSuper {
public static void main(String[] arg) {
Inferieure unInferieure = new
Inferieure(); unInferieure.affiche(); } }
Phénomènes de masquage
class Sup {
int i=1;
void affiche() {
System.out.println("je suis en-haut "); } }
class Inf extends Sup {
int i=2;
void affiche() {
System.out.println("je suis en-bas"); } }
La classe Inf hérite de la classe Sup et définit :

• un attribut de type int, appelé i, initialisé à 2. On dit
que cet attribut masque l'attribut i de la classe Sup.
• une méthode appelée affiche, de même en-tête que
celle de la classe Sup. On dit que cette méthode
redéfinit la méthode affiche de la classe Sup.
class Masque {public static void main(String[]arg) {

Sup monSup;
Inf monInf = new Inf();
monSup=monInf;
monInf.affiche();
monSup.affiche();
System.out.println("monInf.i vaut "+monInf.i);
System.out.println("monSup.i vaut "+monSup.i);
System.out.println(); ((Sup)monInf).i=100;
System.out.println("monSup.i vaut "+monSup.i);
monInf=(Inf)monSup;
monInf.affiche();
monSup = new Sup();
monSup.affiche();
monInf=(Inf)monSup; } }
Remarque très importante

On constate que la suite d'instructions
:
monSup = new Sup();
monInf=(Inf)monSup;
conduit naturellement à une erreur,
puisque dans ce cas, monSup ne
référence
pas un objet de la classe Inf.
Les méthodes d’accès
Les méthodes d’altération

Exemple : class point

public class Point
{ x = abs ;
y = ord ;
}
{ x += dx ;
y += dy ;
}
{ System.out.println ("Je suis un point de coordonnees " + x + " " + y) ;
}
private int x ; // abscisse
private int y ; // ordonnee
}
public class TstPoint

{ Point a ;
a = new Point() ;
a.initialise(3, 5) ;
a.affiche() ;
a.deplace(2, 0) ;
a.affiche() ;
Point b = new Point() ;
b.initialise (6, 8) ;
b.affiche() ;
}}
Exemple :Class point
public class Point

{ public Point (int abs, int ord)
{ x = abs ;
y = ord ;
}
{ x += dx ;
y += dy ;
}
{ System.out.println ("Je suis un point de coordonnees " + x + " " + y) ;
}
private int x ; // abscisse
private int y ; // ordonnee
}
public class TstPoint

{ Point a ;
a = new Point(3,5) ;
a.affiche() ;
a.deplace(2, 0) ;
a.affiche() ;
Point b = new Point(6,8) ;
b.affiche() ;
}}
class Point
{ public Point () // constructeur 1 (sans argument)
{x=0; y=0;
}
public Point (int abs) // constructeur 2 (un argument)
{ x = y = abs ;
}
public Point (int abs, int ord ) // constructeur 3 (deux arguments)
{ x = abs ; y = ord ;
}
{ System.out.println ("Coordonnees : " + x + " " + y) ;
}
private int x, y ;
}
public class Surdef2

{ Point a = new Point () ; // appelle constructeur 1
a.affiche() ;
Point b = new Point (5) ; // appelle constructeur 2
b.affiche() ;
Point c = new Point (3, 9) ; // appelle constructeur 3
c.affiche() ;
}
}
class Point
{ public Point(int abs, int ord)
{ x = abs ;
y = ord ;
System.out.println ("constructeur deux arguments : " + x + " " + y) ;
}
public Point()
{ this (0,0) ; // appel Point (0,0) ; doit etre la premiere instruction
System.out.println ("constructeur sans argument") ;
}
private int x, y ;
}
public class Consthis
Point b = new Point() ;
}
}
class A
{ public void f(float x)
{ System.out.println ("f(float) x = " + x ) ;
}
private void f(int n)
{ System.out.println ("f(int) n = " + n) ;
}
public void g()
{ int n=1 ; float x=1.5f ;
System.out.println ("--- dans g ") ;
f(n) ; f(x) ;
}
}
public class Surdfacc

{ A a = new A() ;
a.g() ;
System.out.println ("--- dans main") ;
int n=2 ; float x=2.5f ;
a.f(n) ; a.f(x) ;
}
}
La méthode main()
class param
{
{
String param0;
int param1;
Float param2;
System.out.println("le nombre de paramètre passé est :" + args.length);
param0 = args[0];
param1 = Integer.parseInt(args[1]);
param2 = Float.valueOf(args[2]);
System.out.println("le paramètre 1 est égal :" + param0);
}
}
Affectation et comparaison
d’objets
• Supposons que nous disposions d’une classe
point possédant un constructeur à deux
arguments.
• Point A,B;
• A=new point(3,5);
• B =new point(2,0);
• A=B;//dans ce cas A et B désigne le même
objet et non deux objets de même valeur.
• Si maintenant en déclare trois objets:

• Point A,B,C;
• A=new point(1,10);
• B =new point(2,20);
• C=A;
• A=B;
• B=C;
L’affectation de variables de type objet se
limite à la recopie de références et non les
valeurs des objets.
La notion de clone
• La démarche la plus réaliste c’est de prévoire une
méthode destinée à fournir une copie de l’objet
concerné.
class point{
…
Public point copie(){
Point p =new point(x,y);
p.x=x;p.y=y;return p;}
…
Point a=new point(1,2);
Point b=a.copie();//b est une copie conforme de a
• Cette démarche est utilisable tant que la classe ne

comporte pas de champs de type classe.
• On voit apparaître la distinction usuelle entre:
• La copie superficielle(recopie la valeur de tous les
champs)
• La copie profonde(recopie la valeur des champs
de type primitif et crée une nouvelle référence à
un autre objet de même type et valeur pour les
champs de type classe).
Comparaison d’objets
• Les opérateurs == et != comparent les
références d’objets et non leurs valeurs.
• Point A,B;
• ...
• A==B est vraie uniquement si A et B font
référence à un seul et même objet, et non
pas aux valeur des champs de a et b.
Les objets transmis en argument

d’une méthode
class point{
…
public boolean coincide(point pt){
return ((pt.x==x)&&(pt.y==y))}
…
point a=new point(1,2);
point b=new point(11,22);
point c=new point(1,2);
a.coincide(b)èfalse a.coincide(c) ètrue
Dans le cas d’un argument de type objet la méthode
reçoit la copie de la référence à l’objet.
class Point
{ x = abs ; y = ord ; }
public boolean coincide (Point pt)
{ return ((pt.x == x) && (pt.y == y)) ;
}
private int x, y ;
}
public class Coincide
Point b = new Point (2, 5) ;
Point c = new Point (1,3) ;
System.out.println ("a et b : " + a.coincide(b) + " " + b.coincide(a)) ;
System.out.println ("a et c : " + a.coincide(c) + " " + c.coincide(a)) ;
}
}
class Point
{ x = abs ; y = ord ;
}
public void permute (Point a) // methode d'echange les coordonnees
// du point courant avec celles de a
{ Point c = new Point(0,0) ;
c.x = a.x ; c.y = a.y ; // copie de a dans c
a.x = x ; a.y = y ; // copie du point courant dans a
x = c.x ; y = c.y ; // copie de c dans le point courant
}
{ System.out.println ("Coordonnees : " + x + " " + y) ;
}
private int x, y ;
}
public class Permute
Point b = new Point (5, 6) ;
a.affiche() ; b.affiche() ;
a.permute (b) ; a.affiche() ; b.affiche() ; }}
Objet renvoyé par une méthode

class point{
…
public point symetrique(){
point res;
res=new point(y,x);
return res;}
…
Point a=new point(1,2);
Point b=a.symetrique();
//renvoit l’objet symetrique de a.
class Point
{ x = abs ; y = ord ; }
public Point symetrique()
{ Point res ;
res = new Point (y, x) ;
return res ; }
{ System.out.println ("Coordonnees : " + x + " " + y) ; }
private int x, y ;
}
public class Sym
a.affiche() ;
Point b = a.symetrique() ;
b.affiche() ; }}
La récursivité des méthodes

• Java autorise la récursivité des appels de
méthodes celle-ci peut être :
• Directe : une méthode comporte au moins
un appel à elle même.
• Croisée : l’appel d’une méthode entraîne
l’appel d’une autre qui à son tour appelle la
méthode initiale.
Exemple :
Class test{
…
Public long fac(long n){
If (n>1) return (fac(n-1)*n);
else return 1;}
…
class Util
{ public static long fac (long n)
{ long res ;
System.out.println ("** entree dans fac : n = " + n) ;
if (n<=1) res = 1 ;
else res = fac(n-1) * n ;
System.out.println ("** sortie de fac : res = " + res) ;
return res ;
}
}
public class TstFac2
{ public static void main (String [] args)
{ int n=Integer.parseInt(args[0]);
System.out.println ("Voici sa factorielle : " + Util.fac(n) ) ;
}
}
Les classes internes

(imbrication de définition de classe)
Une classe est dite interne lorsque sa définition est
située à l’intérieur de la définition d’une autre
classe.
Class E{
….
Class I{
…}
}
La classe E est dite externe alors que I est interne.
• Les classes internes jouissent de trois propriétés

particulière:
• Un objet d’une classe interne est toujours associé,
au moment de son instanciation, à un objet d’une
classe externe.
• Un objet d’une classe interne a toujours accès aux
champs et méthodes même privés de l’objet de la
classe externe.
• Un objet d’une classe externe a toujours accès aux
champs et méthodes même privés de l’objet de la
classe interne.
class Cercle public class TstCercl

{ class Centre { public static void main (String
{ public Centre (int x, int y) args[])
{ this.x = x ; this.y = y ; } { Cercle c1 = new Cercle(1, 3, 2.5) ;
public void affiche() c1.affiche() ;
{ System.out.println (x + ", " + y) ; } c1.deplace (4, -2) ;
private int x, y ; c1.affiche() ;
} }
public Cercle (int x, int y, double r) }
{ c = new Centre (x, y) ;
this.r = r ; }
{ System.out.print ("cercle de rayon " + r + " de centre ") ;
c.affiche() ;}
{ c.x += dx ; c.y += dy ; // ici, on a bien acces à x et y }
private Centre c ;
private double r ;
}

Exceptions

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Exceptions

Transféré par

Droits d'auteur :

Formats disponibles

Ce document a été fabriqué par PDFmail (Copyright RTE Multimedia)

La gestion des exceptions

Une exception est chargée de signaler un comportement

Comment agit une exception ?

Comment gérer une exception dans un

le programme s'arrête et la java machine signale une

La JVM n'a pas trouvé de code d'interception de

Programme avec gestion de l'exception

Schéma du fonctionnement d'un tel gestionnaire :

l'affichage obtenu sur la console lors de l'exécution de ce programme

Interception d'exceptions hiérarchisées

Ordre d'interception d'exceptions

Dans un gestionnaire try...catch comprenant plusieurs clauses, la recherche de la

Que s'est-il passé ?

Il est possible de déclencher soi-même des exceptions en utilisant

Déclenchement manuel d'une exception personnalisée

Exceptions vérifiées, non

Toutes les erreurs et exceptions dérivent de la classe Trowable

Toutes les erreurs et exceptions dérivent de la classe Trowable

Exceptions (d’exécution) non

Signale un problème qui risque d’être fatal

C’est à vous de choisir ce que vous voulez

Elles doivent être récupérées et gérées

La majorité des exceptions de Java font partie du package

Toutes les exceptions vérifiées ou non fonctionnent de la même

Méthode propageant une

Une méthode dans laquelle est levée une ou plusieurs exceptions

Redéfinition d'une méthode

Principe de base : la partie throws < liste d'exceptions>

Notez que la méthode meth

Supposons que nous soyons en présence d'un code

Création de ses propres

class PileException extends Exception{

public class Except2

public class test

Dans une classe abstraite, on peut trouver classiquement

• Une classe est abstraite si aucun objet du programme

class Flottant extends Affichable

public class testabst

Traitement générique élémentaire

Un lot a une référence et une marque (celle de l'article).

Protected Article(String reference)

ArticleUnitaire(abstraite) Article (abstraite)

ArticleUnitaire(abstraite) Article (abstraite)

public abstract class Article {

public abstract class ArticleUnitaire extends Article {

public String getMarque() { return marque; }

public class Lot extends Article {

public String getDescriptif() {

public class Stylo extends ArticleUnitaire {

public class Ramette extends ArticleUnitaire {

Devoir pratique à rendre sur cd-Rom

La société établit des factures numérotées (en partant de 1) et datées,

pour 2 clients différents.

Polymorphisme : exemple (1)

Polymorphisme : exemple (2)

public class Poly

public class TabHeter

Une autre situation ou le

public class TabHet2

Connaître le type d'un objet

Utilisation d’une reference de type Object

Point P = new Point(12,8);

• Les collections sont des objets qui