Cours POO 04/03/2020

CHAPITRE 4
LES PACKAGES
LA GESTION DES EXCEPTIONS

II1-B Université de La Manouba – ENSI – 2019/2020

Plan
2

 Les packages
 Les exceptions
Notion d'exception
Définir sa propre exception
Traitement d'une exception
Principe de propagation d'une exception
Le bloc finally
Exception contrôlée vs exception non contrôlée

II1-B 1
Cours POO 04/03/2020

Les packages

Package (paquetage)
4

 La notion de paquetage correspond à un regroupement

logique sous un identificateur commun d’un ensemble de
classes.

 Elle est proche de la notion de bibliothèque que l’on

rencontre dans d’autres langages.

 Elle facilite le développement et la cohabitation de logiciels

conséquents en permettant de répartir les classes
correspondantes dans différents paquetages.

 Le risque de créer deux classes de même nom se trouve

alors limité aux seules classes d’un même paquetage.

II1-B 2
Cours POO 04/03/2020

Attribution d’une classe à un paquetage

5

 Un paquetage est caractérisé par un nom qui est soit un simple

identificateur, soit une suite d’identificateurs séparés par des points,
comme dans :
MesClasses
[Link]
[Link]
 L’attribution d’un nom de paquetage se fait au niveau du fichier
source: toutes les classes d’un même fichier source appartiendront
donc toujours à un même paquetage.

 Pour ce faire, on place, en début de fichier, une instruction de la

forme :
package xxxxxx ;
dans laquelle xxxxxx représente le nom du paquetage

Utilisation d’une classe d’un paquetage

6

 Pour utiliser une classe appartenant à un

paquetage, il est nécessaire de fournir l’information
correspondante au compilateur.

 Pour ce faire, il faut:

citer le nom du paquetage avec le nom de la classe,
utiliser une instruction import en y citant soit une classe
particulière d’un paquetage, soit tout un paquetage.

II1-B 3
Cours POO 04/03/2020

En citant le nom de la classe

7

 Si vous avez attribué à la classe Point le nom de

paquetage MesClasses par exemple, vous pourrez
l’utiliser simplement en la nommant [Link].
 Par exemple :
[Link] p = new [Link] (2, 5) ;
.....
[Link]() ; // ici, le nom de paquetage n’est pas
requis
 Evidemment, cette démarche devient fastidieuse
dès que de nombreuses classes sont concernées.

En important une classe

8

 L’instruction import permet de citer le nom (complet)

d’une ou plusieurs classes:
import [Link], [Link] ;

 À partir de là, utiliser les classes Point et Cercle

sans avoir à mentionner leur nom de paquetage.

II1-B 4
Cours POO 04/03/2020

En important un paquetage
9

 La démarche précédente s’avère elle aussi fastidieuse dès

qu’un certain nombre de classes d’un même paquetage sont
concernées.
 Pour utiliser toutes les classes du paquetage MesClasses :
import MesClasses.* ;
 Précautions
L’instruction : import MesClasses ;
ne concerne que les classes du paquetage MesClasses.
Si, par exemple, il y a paquetage nommé
MesClasses.Projet1, ses classes ne seront nullement
concernées

Les paquetages standards

10

 Les nombreuses classes standard avec lesquelles

Java est fourni sont structurées en paquetages.

 Il existe un paquetage particulier nommé [Link]

qui est automatiquement importé par le compilateur:
permet d’utiliser des classes standard telles que
Math, System, Float ou Integer, sans avoir à
introduire d’instruction import.

II1-B 5
Cours POO 04/03/2020

11

La gestion des exceptions

12

II1-B 6
Cours POO 04/03/2020

13

14

II1-B 7
Cours POO 04/03/2020

Gérer les circonstances exceptionnelles

15

 Même lorsqu’un programme est au point, certaines circonstances

exceptionnelles peuvent compromettre la poursuite de son exécution
données incorrectes
la rencontre d’une fin de fichier prématurée (alors qu’on a besoin
d’informations supplémentaires pour continuer le traitement).

 Solution 1: Examiner toutes les situations possibles au sein du

programme et prendre les décisions qui s’imposent. Sauf que:
Le programmeur risque d’omettre certaines situations,
Complexité du code: sa tâche principale est masquée par de
nombreuses instructions de traitement de circonstances exceptionnelles.
Il est fréquent que le traitement d’une anomalie ne puisse pas être fait
par la méthode l’ayant détectée, mais seulement par une méthode ayant
provoqué son appel.
Cette dissociation entre la détection d’une anomalie et son traitement
peut obliger le programmeur à utiliser des valeurs de retour de
méthode servant de compte rendu: Problème pour le cas des
constructeurs

Gérer les circonstances exceptionnelles

16

 Solution 2: Java dispose d’un mécanisme très

souple nommé gestion d’exception, qui permet à la
fois :

de dissocier la détection d’une anomalie de son

traitement
de séparer la gestion des anomalies du reste du code,
donc de contribuer à la lisibilité des programmes

II1-B 8
Cours POO 04/03/2020

Une exception
17

Lancer une exception en c++

18

II1-B 9
Cours POO 04/03/2020

Une exception en JAVA

19

 Une exception est une rupture de séquence

déclenchée par une instruction throw comportant une
expression de type classe.
 Il y a alors branchement à un ensemble d’instructions
nommé "gestionnaire d’exception".
 Le choix du bon gestionnaire est fait en fonction du
type de l’objet mentionné à throw (de façon
comparable au choix d’une fonction surdéfinie).

Comment déclencher une exception

avec throw ?
20

 Considérons une classe Point, munie d’un constructeur à deux

arguments et d’une méthode affiche. On ne voudrait manipuler que
des points ayant des coordonnées non négatives:
Au sein du constructeur, vérifier la validité des paramètres fournis.
Lorsque l’un d’entre eux est incorrect, déclencher une exception à l’aide
de l’instruction throw.
Lui fournir un objet dont le type servira ultérieurement à identifier
l’exception concernée.
Créer une classe ErrCoord.
Java impose que cette classe dérive de la classe standard Exception.

class ErrConst extends Exception

{}

II1-B 10
Cours POO 04/03/2020

Comment déclencher une exception

avec throw ?
21

 Pour lancer une exception de ce type au sein du constructeur, fournir

à l’instruction throw un objet de type Errconst :
throw new ErrConst() ;
méthode susceptible de
class Point déclencher une exception
{ de type ErrConst
public Point(int x, int y) throws ErrConst
{
if ( (x<0) || (y<0)) throw new ErrConst() ; // lance une exception de
this.x = x ; this.y = y ; // type ErrConst
}
}

Utilisation d’un gestionnaire d’exception

22

 Gérer convenablement les éventuelles exceptions

de type ErrConst que son emploi peut déclencher.
 Pour ce faire, il faut :
inclure dans un bloc particulier dit "bloc try" les
instructions dans lesquelles on risque de voir l’exception
déclenchée
un tel bloc se présente ainsi :
try
{
// instructions
}

II1-B 11
Cours POO 04/03/2020

Utilisation d’un gestionnaire d’exception

23

 Faire suivre ce bloc de la définition des différents gestionnaires

d’exception. Chaque définition de gestionnaire est précédée d’un
en-tête introduit par le mot-clé catch (comme si catch était le nom
d’une méthode gestionnaire).
 Voici ce que pourrait être notre unique gestionnaire :
catch (ErrConst e)
{ [Link] ("Erreur construction ") ;
[Link] (-1) ;
}
 Ici, un message est affiché et l’exécution du programme est
interrompue en appelant la méthode standard [Link] (la valeur
de l’argument est transmis à l’environnement qui peut éventuellement
l’utiliser comme "compte rendu").
 provoque la sortie du bloc try (et, de surcroît, l’arrêt de l’exécution),

Le programme complet
24

II1-B 12
Cours POO 04/03/2020

Remarque
25

 le bloc try et les gestionnaires associés doivent être

contigus.
 Cette construction est erronée

Exercice
26

 Réaliser une classe EntNat permettant de manipuler des

entiers naturels (positifs ou nuls).
 Pour l’instant, cette classe disposera simplement :
d’un constructeur à un argument de type int qui générera
une exception de type ErrConst (type classe à définir)
lorsque la valeur reçue ne conviendra pas,
d’une méthode getN fournissant sous forme d’un int, la
valeur encapsulée dans un objet de type EntNat.
 Écrire un petit programme d’utilisation qui traite
l’exception ErrConst en affichant un message et en
interrompant l’exécution.

II1-B 13
Cours POO 04/03/2020

27

class EntNat
{ public EntNat (int n) throws ErrConst
{ if (n<0) throw new ErrConst() ;
this.n = n ;
}
public int getN () { return n ; }
private int n ;
}
class ErrConst extends Exception
{}

28

public class TstEntNat

{ public static void main (String args[])
{ try
{ EntNat n1 = new EntNat(20) ;
[Link] ("n1 = " + [Link]()) ;
EntNat n2 = new EntNat(-12) ;
[Link] ("n2 = " + [Link]()) ;
}
catch (ErrConst e)
{ [Link] ("*** erreur construction ***") ;
[Link] (-1) ;
}
}
}

II1-B 14
Cours POO 04/03/2020

Gérer plusieurs exceptions

29

 Considérons une classe Point munie :

du constructeur précédent, déclenchant toujours une
exception ErrConst,
d’une méthode deplace qui s’assure que le déplacement
ne conduit pas à une coordonnée négative ; si tel est le
cas, elle déclenche une exception ErrDepl (on crée donc,
ici encore, une classe ErrDepl) :
public void deplace (int dx, int dy) throws ErrDepl
{ if ( ((x+dx)<0) || ((y+dy)<0)) throw new ErrDepl() ;
x += dx ; y += dy ;
}

Gestion de plusieurs exceptions

30

 Lors de l’utilisation de la classe Point, nous pouvons détecter les deux

exceptions potentielles ErrConst et ErrDepl en procédant ainsi :

try
{ // bloc dans lequel on souhaite détecter les exceptions ErrConst et ErrDepl
}
catch (ErrConst e) // gestionnaire de l’exception ErrConst
{ [Link] ("Erreur construction ") ;
[Link] (-1) ;
}
catch (ErrDepl e) // gestionnaire de l’exception ErrDepl
{ [Link] ("Erreur deplacement ") ;
[Link] (-1) ;
}

II1-B 15
Cours POO 04/03/2020

Transmission d’information au gestionnaire

d’exception
31

 On peut transmettre une information au

gestionnaire d’exception :

1. par le biais de l’objet fourni dans l’instruction throw,

2. par l’intermédiaire du constructeur de l’objet
exception

Par l’objet fourni dans l’instruction throw

32

 L’objet fourni à l’instruction throw sert à choisir le bon

gestionnaire d’exception.
 Il est aussi récupéré par le gestionnaire d’exception
sous la forme d’un argument: on peut l’utiliser pour
transmettre une information.
 Il suffit pour cela de prévoir les champs appropriés
dans la classe correspondante (on peut aussi y
trouver des méthodes).

II1-B 16
Cours POO 04/03/2020

La classe ErrConst
possède les champs abs et ord
permettant de transmettre les
coordonnées reçues par le
33 constructeur de Point

Valeurs fixées lors de

la construction d’un
objet de type ErrConst
et récupérées
directement par le
gestionnaire (car les
champs ont été prévus
publics ici, pour
simplifier les choses).

Par le constructeur de la classe exception

34

 Exploiter une particularité de la classe Exception: En

effet, celle-ci dispose d’un constructeur à un
argument de type String dont on peut récupérer la
valeur à l’aide de la méthode getMessage (dont
héritera la nouvelle classe).

 Pour bénéficier de cette facilité, il suffit de prévoir

dans la classe exception, un constructeur à un
argument de type String, qu’on retransmettra au
constructeur de la super-classe Exception

II1-B 17
Cours POO 04/03/2020

35

Le mécanisme de gestion des exceptions

36

1. la poursuite de l’exécution après le traitement

d’une exception par le gestionnaire,
2. le choix du gestionnaire,
3. les règles d’écriture de la clause throws,
4. les possibilités de redéclencher une exception,
5. l’existence d’un bloc particulier dit finally

II1-B 18
Cours POO 04/03/2020

1- Poursuite de l’exécution
37

 Le gestionnaire d’exception mettait fin à l’exécution

du programme en appelant la méthode [Link].
Cela n’est pas une obligation

 Après l’exécution des instructions du gestionnaire,

l’exécution se poursuit simplement avec les
instructions suivant le bloc try (plus précisément, le
dernier bloc catch associé à ce bloc try).

38

avant bloc try

coordonnees : 1 4
Erreur deplacement
apres bloc try

II1-B 19
Cours POO 04/03/2020

39

 Un gestionnaire d’exception peut aussi comporter une

instruction return. Celle-ci provoque la sortie de la méthode
concernée (et pas seulement la sortie du gestionnaire !)
int f()
{
try
{ .....
}
catch (Exception E1 e)
{ .....
return 0 ; // OK ; en cas d’exception, on sort de f
}
..... // sans executer ces instructions
}

Portée des identificateurs

40

 Les blocs catch ne sont pas traités comme des méthodes mais
bel et bien comme de simples blocs.
 Il est possible dans un bloc catch d’accéder à certaines
variables appartenant à un bloc englobant
int f()
{ int n = 12 ;
try
{ float x ;
.....
}
catch (Exception E1 e)
{ // ici, on n’a pas accès a x (bloc disjoint de celui-ci)
// mais on a accès a n (bloc englobant)
}

II1-B 20
Cours POO 04/03/2020

2- Choix du gestionnaire d’exception

41

 Lorsqu’une exception est déclenchée dans un bloc try,

on recherche parmi les différents gestionnaires associés
celui qui correspond à l’objet mentionné à throw.

 L’examen a lieu dans l’ordre où les gestionnaires

apparaissent. On sélectionne le premier qui est soit du
type exact de l’objet, soit d’un type de base
(polymorphisme).

 Cette possibilité peut être exploitée pour regrouper

plusieurs exceptions qu’on souhaite traiter plus ou moins
finement.

42

 Supposons que les exceptions ErrConst et ErrDepl sont

dérivées d’une même classe ErrPoint :
class ErrPoint extends Exception { ..... }
class ErrConst extends ErrPoint { ..... }
class ErrDepl extends ErrPoint { ..... }

 Considérons une méthode f déclenchant des exceptions

de type ErrPoint et ErrDepl :
void f ()
{ .....
throw ErrConst ;
.....
throw ErrDepl ;
}

II1-B 21
Cours POO 04/03/2020

OK
43

OK

OK

Aucune chance de passer au

deuxième catch

3-La clause throws

44

Toute méthode susceptible de déclencher une exception qu’elle ne traite

pas localement doit mentionner son type dans une clause throws figurant
dans son en-tête.

 Cette règle concerne les exceptions que la méthode

peut déclencher directement par l’instruction throw, mais
aussi toutes celles que peuvent déclencher (sans les
traiter) toutes les méthodes qu’elle appelle.

 Autrement dit, la clause throws d’une méthode doit

mentionner au moins la réunion de toutes les exceptions
mentionnées dans les clauses throws des méthodes
appelées.

II1-B 22
Cours POO 04/03/2020

45

 méthode_1 appelle méthode_2, qui appelle méthode 3

Méthode_1 Méthode_2 Méthode_3

 Si méthode 3 génère une exception

Message d’exception est envoyé à méthode_2
Méthode_2 peut
 Traiter (attraper) l’exception
 Relancer l’exception: le message d’exception sera envoyé à méthode_1
 …
 Si une exception n’est traitée par aucune méthode qui appelle: sortie du
programme avec un message d’exception

4- Redéclenchement d’une exception

46

 Dans un gestionnaire d’exception, il est possible de demander que,

malgré son traitement, l’exception soit retransmise à un niveau
englobant, comme si elle n’avait pas été traitée.

 Il suffit pour cela de la relancer en appelant à nouveau l’instruction

throw :
try
{ .....
}
catch (Excep e) // gestionnaire des exceptions de type Excep
{ .....
throw e ; // on relance l’exception e de type Excep
}

II1-B 23
Cours POO 04/03/2020

Exemple
47

dans catch (ErrConst) de f

dans catch (ErrConst) de main
apres bloc try main

5-Le bloc finally

48

 Nous avons vu que le déclenchement d’une exception

provoque un branchement inconditionnel au gestionnaire.
 L’exécution se poursuit avec les instructions suivant ce
gestionnaire.
 Java permet d’introduire, à la suite d’un bloc try, un bloc
particulier d’instructions qui seront toujours exécutées :
soit après la fin "naturelle" du bloc try, si aucune exception n’a été
déclenchée (il peut s’agir d’une instruction de branchement
inconditionnel telle que break ou continue),
soit après le gestionnaire d’exception (à condition, bien sûr, que
ce dernier n’ait pas provoqué d’arrêt de l’exécution).
 Ce bloc est introduit par le mot-clé finally et doit
obligatoirement être placé après le dernier gestionnaire

II1-B 24
Cours POO 04/03/2020

Exemple
49

try { ..... } try { ..... }

catch (Ex e) { ..... } catch (Ex e) { ..... }
finally // instructions A
{ // instructions A
}

void f (...) throws Ex

Une exception Ex se produit dans f, on exécutera
{ .....
les instructions A du bloc finally avant de se
try
brancher au gestionnaire approprié.
{ ..... }
finally
Sans la présence de finally, ces mêmes instructions
{ // instructions A }
ne seraient exécutées qu’en l’absence
.....
d’exception dans le bloc try
}

Exercice
50

 Quels résultats fournit ce programme ?

class Except extends Exception
{}
public class Finally
{ public static void f(int n)
{ try
{ if (n!=1) throw new Except () ;
}
catch (Except e)
{ [Link] ("catch dans f - n = " + n) ;
}
finally
{ [Link] ("dans finally - n = " + n) ;
}
}
public static void main (String args[])
{ f(1) ;
f(2) ;
}
}

II1-B 25
Cours POO 04/03/2020

Les exceptions standards

51

 Java fournit de nombreuses classes prédéfinies dérivées de

la classe Exception:
la classe IOException et ses dérivées sont utilisées par les
méthodes d’entrées-sorties.
Certaines classes exception sont même utilisées par la machine
virtuelle à la rencontre de situations anormales telles qu’un indice
de tableau hors limites, une taille de tableau négative...
 Ces exceptions standard se classent en deux catégories.
Les exceptions explicites (on dit aussi sous contrôle) correspondent
à ce que nous venons d’étudier. Elles doivent être traitées par une
méthode, ou bien être mentionnées dans la clause throws.
Les exceptions implicites (ou hors contrôle) n’ont pas à être
mentionnées dans une clause throw et on n’est pas obligé de les
traiter (mais on peut quand même le faire).

Les exceptions standards

52

 Cette classification sépare les exceptions

susceptibles de se produire n’importe où dans le
code de celles dont on peut distinguer les sources
potentielles.
un débordement d’indice ou une division entière par
zéro peuvent se produire presque partout dans un
programme ;
une erreur de lecture, qui ne peut survenir que si l’on
fait appel à des méthodes bien précises

II1-B 26
Cours POO 04/03/2020

Exemples d’exceptions
du package standard [Link]
53

Exceptions explicites Exceptions implicites

Exemple
54

détecte les
exceptions
standard
NegativeArraySi
zeException
et
ArrayIndexOut
OfBoundsExcepti
on et qui utilise
la méthode
getMessage
pour afficher le
message
correspondant

II1-B 27
Cours POO 04/03/2020

55

 La méthode main est déclarée par

public static void main(String args[])
Le paramètre args passé à cette méthode est un
tableau de chaînes de caractères qui contient les
paramètres passés à l'application java sur la ligne
de commande.

 On a accès à ces paramètres en écrivant args[0],

args[1], etc...: le premier paramètre a le numéro 0.
 Le nombre de paramètres est fourni par [Link]

56

Les paramètres passés sur la ligne de

commande sont des chaînes de caractères.

Nous pouvons les transformer en variables de

type int. Cela peut se faire grâce à la
méthode parseInt de la classe Integer.

int n=[Link](S);
permet de convertir la chaîne S en un entier
n.

II1-B 28
Cours POO 04/03/2020

public class Calcul { public static void main(String[] args) {

private int a; [Link]("Debut du main");
public Calcul(int a) { Calcul cal= new Calcul ([Link](args[0]));
this.a = a;} try {
57 public int getA() { cal.m2([Link](args[1]));
return a; } }
public void m1(int b) throws E1,E2 { catch (E2 excpt) {
[Link]("Début de m1"); [Link](excpt);
if (b == 0) }
throw new E1("paramètre de m1 nul"); [Link]("a = " + [Link]());
if (a * b < 0) [Link]*ntln("Fin du main");}
throw new E2(); }
a += a / b; public class E1 extends Exception {
[Link]("Fin de m1");} public E1(String message) {
public void m2(int c) throws E2 { super(message);
[Link]("Début de m2"); }}
try { public class E2 extends Exception {
[Link]("Dans m2 avant appel de m1"); public String toString(){
m1(c); return("paramètre de signe opposé à
[Link]("Dans m2 apres appel de m1"); l’attribut”);} }
}
catch (E1 excpt) { Résultats pour:
[Link]([Link]());
• -4 -2
}
[Link]("Fin de m2");
•10
} • -2 1

II1-B 29