26/05/2025

Exceptions Exceptions
⚫ mécanisme utilisé très fréquemment dans le langage Java
⚫ les exceptions sont rencontrées dans de nombreuses situations dans la signature de méthodes et la documentation des
classes. Certaines exécutions peuvent faire apparaître (lever) des exceptions
Les Exceptions C:>java throwtest 3
i = 3
[Link]
ion: 3 at
throwtest.b([Link]
) at
throwtest.a([Link]
)
at [Link]([Link])

instructions try catch dans les programmes

try {
...
valSurface = [Link]([Link]());
}
catch (NumberFormatException execpt)
{
[Link]("ENTIER !!!");
return; // on sort sans creer d'instance
}

POO en Java 2

1
 26/05/2025

Exceptions Exceptions ??? Exceptions M écanisme

⚫ Mais alors qu’est-ce qu’une traitement normal traitement en cas traitement en cas
(sans exception) d'exception d'exception
exception ? ⚫ Dans un bloc de code ( { .. } ) lorsqu'une situation exceptionnelle est
⚫ Une exception est un signal instruction a; instruction a; rencontrée, une exception est lancée. instruction a;
... ... ...
⚫ qui indique que quelque chose try { try { ⚫ Dans ce bloc, les instructions suivants l'instruction ayant lancé l'exception try {
d'exceptionnel (par exemple une instruction b; instruction b; ne sont pas exécutées instruction b;
... ... ...
erreur) s'est produit, ⚫ L'exception est 'remontée' automatiquement de bloc en bloc jusqu'au
... { ... { ... {
... ... lancement premier catch susceptible de l'attraper et la traiter ... lancement
⚫ qui interrompt le flot d'exécution d'une
instruction b; instruction b; d'une ⚫ Si l'instruction ayant levé l'exception est dans une méthode et que celle ne instruction b;
normal du programme. instruction e; instruction e; exception instruction e; exception
instruction f; instruction f; contient aucune clause catch attrapant l'exception, l'exception est instruction f;
⚫ lancer (throw) une exception ... ... propagée vers la méthode de niveau supérieur. ...
consiste à signaler ce quelque } } code non } code non
exécuté ⚫ et ainsi de suite … exécuté
instruction k; instruction k; instruction k;
chose, ... ... ⚫ Si une exception n'est jamais attrapée : ...
⚫ attraper (catch) une exception } }
⚫ propagation jusqu'à la méthode main() à partir de laquelle
}
catch (...) { catch (...) { catch (...) {
permet d'exécuter les actions code non instruction c; instruction c; traitement de l'exécution du programme a débuté, instruction c; traitement de
nécessaires pour traiter cette exécuté ... ... l'exception ⚫ affichage d'un message d'erreur et de la trace de la pile des appels de ... l'exception
} } }
situation. instruction d; instruction d; méthodes (call stack), instruction d;
reprise du
... ... reprise du
traitement ⚫ arrêt de l'exécution du programme. ...
traitement
normal
normal

POO en Java 3 POO en Java 4

2
 26/05/2025

Exceptions Mécanisme Exceptions Objets except ions

public static void main (String[] args){
4
... Dépassement d’index, arrêt de l’exécution normale
⚫ en JAVA les exceptions sont des objets
. 1
. if (...) { et lancement de ArrayOutOfBoundsException ⚫ toute exception doit être une instance d'une sous-classe de la classe [Link]
13 ...
14 methodeX() 2 Transmission du contrôle au bloc de niveau supérieur
15 ... Récupérables le programme a la
} Si il y a du code pour traiter (attraper) l’exception, traitement de l'exception possède deux sous- Throwable possibilité d'attraper ces
. 3
. ... et reprisedu flot d ’exécution normal classes standards exceptions
. } STOP
7 Sinon on recommence comme en 2 (transmission au bloc de niveau non récupérables
. 4
31 public static void methodeX(){ supérieur) erreurs "systèmes"
. ... Si aucun code dans la méthode pour traiter l’exception le contrôle est (plus de mémoire,
6
. Point[] pts = new Point[10]; 5 transmis au niveau de la méthode appelante et on recommence comme problèmes chargement
... {
Error Exception
39 en 2 dynamique...)
40 Point b = barycentre(pts);
41 ...
}
6 Et ainsi de suite... pour définir de nouveaux types
.
. ... d'exceptions, en général, on
Jusqu’à ce que l’on aboutisse au bloc du programme principal, alors arrêt
. } 7 LinkageError RunTimeException IOException MyException1 sous-classera (directement ou
public static Point barycentre(Point[] pts){
de l’exécution et impression de la pile des appels (stack trace).
65 indirectement ) de
. ... [Link]
type de l'exception éventuel message explicatif
. if (...) {
71 for (int i = 0; i <= [Link]; i++) {
>java App
72 ...
...pts[10] 1 5 Exception in thread "main" [Link] : Index
73 10 out of bounds for length 10 exception levée dans méthode ArrayIndexOutOfBounds
74 ... 2 at [Link]([Link]) EOFException FileNotFoundException
barycentre ligne 73 Exception
. } at [Link]([Link]) barycentre a été appelée dans
. 3 ... at [Link]([Link])
méthode methodeX ligne 40
. } 4 >
... methodeX a été appelée ligne 14 MyException2
.
. } du programme principal

POO en Java 5 POO en Java 6

3
 26/05/2025

Exceptions Objets except ions Exceptions Objets except ions

⚫ Puisqu'elles sont des objets les exceptions peuvent contenir : ⚫ La représentation des exceptions sous forme d'objets permet de mieux structurer la description et le traitement des
⚫ des attributs particuliers, erreurs
⚫ des méthodes.

⚫ Attributs et méthodes standards (définis dans [Link])

Throwable "Because all exceptions that are thrown within a Java program
contient un message d'erreur décrivant l'exception are first-class objects, grouping or categorization of exceptions
String message
Permet le «chaînage»
Throwable cause
is a natural outcome of the class hierarchy. Java exceptions
des exceptions
must be instances of Throwable or any Throwable descendant.
Throwable() constructeurs (sans et avec message d ’erreur)
Throwable(String message)
As for other Java classes, you can create subclasses of the
Throwable(Throwable cause)
Throwable class and subclasses of your subclasses.
Throwable (String message, Each "leaf" class (a class with no subclasses) represents
Throwable cause) a specific type of exception and each "node" class (a class with
renvoie le message d'erreur décrivant l'exception one or more subclasses) represents a group of
String getMessage()
void printStackTrace()
related exceptions. "
affiche sur la sortie erreur standard la liste des appels de
Throwable getCause() méthodes ayant conduit à l'exception (backtrace).
[The Java Tutorial, Campione &Walrath 97]

POO en Java 7 POO en Java 8

4
 26/05/2025

Exceptions Objets except ion Exceptions Objets except ion

⚫ On peut être amené à définir une hiérarchie de classes (sans nécessairement définir de nouveaux attributs et
⚫ Les exceptions étant des objets, leur structuration en une hiérarchie de classes permet de les traiter à
différents niveaux d'abstraction (via polymorphisme) nouvelles méthodes) uniquement dans un souci de structuration et de typage des exceptions

Exception
En langage C En Java
class CompteException extends Exception {
#define EOF_ERROR 1
private int noCompte;
#define FILENOTFOUND_ERROR 2 Exception public CompteException(int c, String mess)
#define ZIP_ERROR 3 CompteException
{ super(mess);noCompte = c;
} int noCompte
public int noCompte() { return noCompte; CompteException(c : int, mess :String)
Niveau d'abstraction qui }} getNoCompte() : int
IOException permet de désigner toutes
les exceptions liées au E/S

class CompteOpException extends

CompteNotFoundException CompteOpException CompteException {
EOFException FileNotFoundException ZipException public CompteOpException(int c, String
mess) {super(c,mess);}}
class CompteNotFoundException extends
CompteException { public
CompteNotFoundException(int c, String mess) DebiterException VirerException
{super(c,mess);}}

POO en Java 9 POO en Java 10

5
 26/05/2025

Exceptions Trait ement Exceptions Trait ement

⚫ try{ … } délimite un ensemble d'instructions susceptibles de déclencher une(des) exception(s) pour la(les)quelles une
gestion est mise en œuvre
⚫ unbloc try est suivi par une ou plusieurs clauses catch qui permettent d'intercepter ("attraper") les
⚫ cette gestion est réalisée par des blocs catch(TypeDexception e){ … } qui suivent le bloc try
exceptions dont le type est spécifié (dans la clause catch) et d'exécuter alors du code spécifique.
⚫ permettent d'intercepter ("attraper") les exceptions dont le type est spécifié et d'exécuter alors du code spécifique.

try {
⚫ un seul bloc catch peut être exécuté : le premier suceptible "d'attraper" l'exception.
String nomFichier;
String[] lireTexte(String nomfic){
...
⚫ chaque clause catch doit être déclarée avec un argument de type Throwable ou une sous-classe de
[Link]("nom fichier :");
nomFichier = [Link](); ... Throwable
FileReader f= new FileReader(
String[] text=lireTexte(nomFichier);
for (int i = 0; i < [Link]; i++) {
new File(nomfic)); ⚫ quand une exception est levée dans le bloc try, la première clause catch dont le type de l'argument
...
}
[Link](text[i]);
...
Le fichier correspond à celui de l'exception levée est invoquée
... n'existe pas !
...
return ... ; création d’un objet FileNotFoundException ⚫ clause catch dont l'argument est de même classe que l'exception levée,
} et arrêt de l‘exécution normale
} ⚫ clause catch dont l'argument est une super-classe de la classe de l'exception levée.
catch (FileNotFoundException e) {
[Link]();
[Link]([Link]());
... Traitement local de l’erreur ⚫ l'ordre des blocs catch est donc très important.
}
...
... Poursuite de l ’exécution

POO en Java
11 POO en Java 12

6
 26/05/2025

Exceptions Trait ement Exceptions Trait ement

Exemple : Exemple :

... ...
try {
Exception de type : Except1 try {
// séquence de code pouvant lever
Exception ou Except2 ou Except3 // séquence de code pouvant lever Exception
Exception de type Except1 //des exceptions de type Except1,
//des exceptions de type Except1,
// Except2 ou Except3
// Except2 ou Except3
...
...
}
}
? catch (Except2 ex) {
Except1 quel bloc catch va la catch (Except2 ex) { Except
Except1
1 // e1 est l'exception qui a été levée
traiter ? // e1 est l'exception qui a été levée // dans le bloc try
//dans le bloc try Types ne
[Link]([Link]()); [Link]([Link]());
? correspondent pas, on
[Link](); [Link]();
passe au bloc catch // ...
Except2 // ... Except2 suivant
}
? catch (Except1 ex) {
catch (Except1 ex) { Types //
// ... correspondent } ...
} exécution du bloc
catch catch (Except3 ex) {
Except3 catch (Except3 ex) { Except3
// ...
// ... les blocs catch
}
} suivants sont ignorés
et poursuite de ...
l’exécution

POO en Java 13 POO en Java 14

7
 26/05/2025

Exceptions Trait ement Exceptions Trait ement

Exemple : Exemple :

... ...
try { L ’ordredes blocs try {
Exception Exception catch doit respecter
Exception de type Except3 // séquence de code pouvant lever l’ordreinversede l'ordre // séquence de code pouvant lever
//des exceptions de type Except1, d’héritage entre les //des exceptions de type Except1,
// Except2 ou Except3
classes d’exception
... ...
} }
? catch (Except2 ex) { catch (Except3
catch (Except2 ex)
ex) {
{
Except1 // e1 est l'exception qui a été levée Except1 //...
e1 est l'exception qui a été levée
//
Types correspondent un // dans le bloc try // dans le bloc try
}
objet Except3 est un [Link]([Link]()); [Link]([Link]());
objet Except2 [Link](); [Link]();
catch (Except2 ex) {
// ... // ...
// e1 est l'exception qui a été levée
} } // dans le bloc try
Except2 Except2
[Link]([Link]());
catch (Except1 ex) { catch (Except1 ex) {
[Link]();
// ... //
//...
...
} }
}
catch (Except3 ex) { catch (Except1
catch (Except3 ex)
ex) {
{
Except3 le bloc catch Except3 Except3
// ... // ...
// ...
ne peut jamais être atteint } }
P:\Java\Tests\>javac [Link] }
d’ailleurs le compilateur ... [Link]: catch not reached ...
catch (Except3 e3) { ...
le signale
^
1 error
POO en Java 15 POO en Java 16

8
 26/05/2025

Exceptions Trait ement Exceptions Trait ement : finalisation

⚫ pas nécessaire d'avoir clause catch pour chaque type possible d'exception pouvant être levée.
⚫ lesclauses catch sont suivies de manière optionnelle par un bloc finally qui contient du code qui sera
⚫ si aucun bloc catch ne permet d'attraper l'exception, celle-ci est propagée vers la méthode appelante exécuté quelle que soit la manière dont le bloc try a été quitté
qui a alors la charge de la traiter ou non
⚫si une exception n'est attrapée par aucune des méthodes présentes dans la pile des appels alors un message d'erreur ainsi que la ⚫ le bloc finally permet de spécifier du code dont l'exécution est garantie quoi qu'il arrive :
trace de la pile d'appels sont affichés et l'exécution du programme est interrompue.

⚫ le bloc try s'exécute normalement sans qu'aucune exception ne soit levée

Exception ⚫ la fin du bloc try a été atteinte,
... ⚫contrôle quitte le bloc try suite à une instruction return, continue, break (d'ou parfois l'utilisation d'un
try { Except4
bloc try avec un bloc finally sans clauses catch).
Except1 Except4 // séquence de code pouvant lever les exceptions de type
// des exceptions de Except4 seront reportées
Except1 // type Except1 , Except2,
// Except3 ou Except4
au niveau de la méthode ⚫ le bloc try lève une exception attrapée par l'un des blocs catch.
Except2
... appelante
Except3
Except2 }
Le bloc catch catch
catch (Except1
(Except1e1)
e1) ⚫ le bloc try lève une exception qui n'est attrapée par aucun des blocs catch qui le suivent.
traitera toutes les {{
exceptions de type ////
...
...
Except1, Except2 ou }}
Except3
Except3

POO en Java 17 POO en Java 18

9
 26/05/2025

Exceptions Trait ement : finalisat ion Exceptions Lan c ement

⚫ interêt double :
⚫ permet de rassembler dans un seul bloc un ensemble d'instructions qui autrement auraient du être dupliquées
⚫ permet d'effectuer des traitements après le bloc try, même si une exception a été levée et non attrapée par
⚫ l'instruction
throw unObjetException permet de lancer une exception
les blocs catch ⚫ unObjetException doit être une référence vers une instance d'une sous-classe de Throwable

⚫ quand une exception est lancée,

... ...
try { try {
// ouvrir un fichier // ouvrir un fichier 1. l'exécution normale du programme est interrompue,
// effectuer des traitements // effectuer des traitements
// susceptibles //susceptibles 2. la JVM recherche la clause catch la plus proche permettant de traiter l'exception lancée,
// de lever une exception // de lever une exception
// fermer le fichier } 3. cette recherche se propage au travers des blocs englobants et remonte les appels de méthodes
} catch (CertaineException e)
catch (CertaineException e) { jusqu'à ce qu'un gestionnaire de l'exception soit trouvé,
{ // traiter l'exception
// traiter l'exception } 4. tous les blocs finally rencontrés au cours de cette propagation sont exécutés.
// fermer le fichier catch (AutreTypeException e)
} {
catch (AutreTypeException e) // traiter l'exception Le bloc finally est
{ } toujours exécuté
// traiter l'exception finally {
// fermer le fichier //fermer le fichier
} }

POO en Java
POO en Java 19 20

10
 26/05/2025

Exceptions Lan cem ent Exceptions Décla ratio n

⚫ Exemple : violation d’une précondition
class OperationBancaireException extends Exception { ⚫ Touteméthode susceptible de lever une exception "normale" doit
2. Définition d’une nouvelle classe
/** d ’exception ⚫ soit l'attraper,
* compte pour lequel l’opération a échouée
*/ ⚫ soit la déclarer explicitement, c'est à dire comporter dans sa signature l'indication que l'exception peut
private Compte c;
être provoquée : clause throws
public OperationBancaireException(Compte c,String s)
{
super(s);
public class Compte { ⚫ Lesexceptions déclarées dans la clause throws d ’une méthode sont :
this.c = c; 1. L’opération ne peut être effectuée
} protected double solde = 0;
... que si le dépôt est >= 0 ⚫ les exception levées dans la méthode et non attrapées par celle-ci,
}
/** ⚫ les exceptions levées dans des méthodes appelées par la méthode et non attrapées par celle-ci.
* Dépôt d’argent sur le compte
* @param s la somme à déposer, s doit être >= 0 4. L ’exception doit être
* @throws OperationBancaireException si s <=0 signalée dans la signature
*/ de la méthode
public void créditer(double s) {throws OperationBancaireException {
3. Si la précondition n ’est if (s < 0) {
pas vérifiée création et throw new OperationBancaireException(this, "dépôt incorrect");
lancement d ’une exception }
solde += s;
}
...
}

POO en Java 21
17 POO en Java 22

11
 26/05/2025

Exceptions Décla ratio n Exceptions Décla ratio n

class MonException extends Exception { public class TestExcep { class MonException extends Exception { public class TestExcep {

public MonException() { public void method1() throws MonException { public MonException() { public void method1() throws MonException {
super(); throw (new MonException()); super(); throw (new MonException());
} } } }

public MonException(String s) { public void method2() { public MonException(String s) { public void method2() {
super(s); method1(); super(s); method1();
} } } }
} }
} }

Pour avoir une compilation correcte il faut modifier

Si on oublie de traiter une exception le compilateur le signale :-)
method2
soit en "attrapant" l'exception
[Link]-2.02$ javac [Link] soit en en déclarant explicitement que
[Link]: Exception MonException must be caught, Les exceptions public void method2() {
or it must be declared in the throws clause of this contrôlées method2 est susceptible de lancer une try {

method. doivent être soit exception de type MonException method1();

}
method1(); attrapées soit
catch (MonException e) {
^ relancées ! public void method2() throws MonException { [Link]();
method1(); }
1 error } }
[Link]-2.02$

POO en Java POO en Java

23 24

12
 26/05/2025

Exceptions Décla ratio n Exceptions Décla ratio n

⚫ plusieurs classes d ’exceptions peuvent être indiquées dans la clause throws d’une déclaration de méthode ⚫ la classeutilisée pour les exceptions dans la clause throws peut être une superclasse de la classe de
l'exception effectivement lancée

void methodeQuelconque() throws Except1,Except4 {

Exception try { Exception

// séquence de code pouvant

// lever des exceptions public void methodeQuelconque()
// de type Except1, Except2, {
Except1 Except4 // Except3 ou Except4 Except1 Except4 Except4 Except3,
throws Except1, Except2, { Except4
Les exceptions de type Except1
...
et Except4 ne sont pas traitées // séquence de code pouvant
} // lever des exceptions
catch (Except2 m) dans le corps de la méthode, elles
// de type Except1,
{ doivent être déclarées dans la
Except2 Except2 // Except2, Except3 ou Except4
// intercepte les exceptions clause throws ...
// de type Except2 et Except3 Les exceptions de type Except1 ,
... Except2, Except3 et Except4
} } ne sont pas traitées dans le corps
finally de la méthode, elles doivent être
Except3 { Except3
// ...
déclarées dans la clause throws
}
}

POO en Java 25 POO en Java 26

13
 26/05/2025

Exceptions Redéfinition de méthodes Exceptions Redéfinition de méthodes

Exception public Class A { Exception public Class A {

void methodeX() throws Except1, Except4 { void methodeX() throws Except1, Except4 {
Except1 Except4 Except5 // séquence de code pouvant Except1 Except4 Except5 // séquence de code pouvant
// lever des exceptions // lever des exceptions
// de type Except1, // de type Except1,
Except2 // ou Except4 Except2 // ou Except4
... ...
Except3 } }
Except3
... ...
} }
Lorsque l'on redéfinit la Mais alors, la méthode redéfinie
méthode peut-on lancer de doit-elle avoir nécessairement la La clause throws peut être "spécialisée"
nouveaux types d'exception ? même clause throws ? (typage covariant de la clause throws)
public Class B extends A { public Class B extends A {

Pas
NON !
void methodeX() throws Except1, Except4 , Except5 { void methodeX() throws Except1
Except3,, Except4 {
[Link](); ...
... nécessairement ! ...
// séquence de code pouvant lever une // séquence de code pouvant lever une
// exception de type Except5 // exception de type Except3 ou Except4
⚫ La méthode redéfinie doit respecter le contrat ... ...

défini par la méthode originale. Elle ne peut } ⚫ La méthode redéfinie peut lancer des exceptions } public Class C extends A {
... ... void methodX() {
rajouter de nouveaux types d'exception } spécialisant les exceptions définies dans la clause } // séquence de code ne levant
// pas d'exception
throws de la méthode originale ...
}
...
}

POO en Java 27 POO en Java 28

14
 26/05/2025

Exceptions Décla ratio n Exceptions Objets except ions

⚫ l'obligation de déclaration des exceptions présente un double intérêt

Throwable possède deux sous-classes standards
⚫ celui qui écrit une méthode doit être conscient de toutes les exceptions levées par les méthodes qu'il appelle.
Pour ces exceptions il doit choisir entre les traiter ou les déclarer. Il ne peut les ignorer.
⚫ celui qui utilise la méthode apprend grâce aux clauses throws quelles sont les exceptions susceptibles d'être Exceptions non récupérables Exceptions récupérables
levées par cette méthode et les méthodes appelées. Error Exception

⚫ poursimplifier écriture des programmes (et permettre une extensibilité future) les
exceptions "standards" non pas besoin d'être déclarées LinkageError RunTimeException IOException

⚫ exceptions définies comme sous classes de Error

erreurs "systèmes" empêchant l’exécution du
⚫ exceptions définies comme sous classes de RuntimeException programme (plus de mémoire, problèmes
chargement dynamique...)
⚫ Exemples : ArrayOutOfBoundException, NullPointerException …

Exceptions non contrôlées (unchecked) Exceptions contrôlées (checked)

Pas d’obligation de déclaration Obligation de déclaration

POO en Java POO en Java

29 30

15
 26/05/2025

Exceptions N’ignorez pas les exc eptio ns Exceptions I nt érêt

⚫ Exemple : écriture d’une méthode qui ouvre et charge en mémoire un fichier
try{

... Bloc catch vide, détruit la finalité des

exceptions qui est de vous obliger à void readFile() {
} catch (SomeException e) {
Code très, très suspect… traiter les conditions exceptionnelles open the file;
}
qu’elles sont supposer représenter. determine its size;
allocate that much memory;
read the file into memory;
close the file;
}

catch (SomeException e) { catch (SomeException e) {

[Link](…); // commentaire MAIS que se passe t'il si
[Link](); // justifiant le fait de • le fichier ne peut être ouvert ?
[Link](0); // ne rien faire
• si sa taille ne peut être déterminée ?
} }
• si il n'y a pas assez de mémoire disponible ?
• si il se produit une erreur de lecture ?
• si le fichier ne peut être fermé ?

POO en Java POO en Java

31 32

16
 26/05/2025

Exceptions I nt érêt Exceptions I nt érêt

errorCodeType readFile() {
initialize errorCode = 0;
open the file;
void readFile() { ⚫ Avec le mécanisme d ’exceptions le code « normal » et mieux
try { séparé du code de gestion des erreurs
if (theFileIsOpen) { ⚫ Sans mécanisme d’exceptions il faut ajouter dans le code de la open the file;
determine the length of the file;
if (gotTheFileLength) { méthode des instructions pour détecter, rapporter et gérer les determine its size;
allocate that much memory; erreurs, utilisation de code d ’erreur en retour des fonctions allocate that much memory;
if (gotEnoughMemory) { read the file into memory;
read the file into memory;
close the file;
if (readFailed) {
errorCode = -1; →augmentation conséquente de la taille du code } catch (fileOpenFailed) {
→ Code plus concis
} (de 7 lignes de codes on passe à 29 lignes !) doSomething;
} else { } catch (sizeDeterminationFailed) {
errorCode = -2;
→perte de lisibilité (le code devient un plat de spaghetti) doSomething; → Code plus lisible
} } catch (memoryAllocationFailed) {
} else {
doSomething;
errorCode = -3;
} catch (readFailed) {
} → que faire pour les fonctions qui doivent renvoyer
close the file; doSomething;
if (theFileDidntClose && errorCode == 0) { un résultat ? } catch (fileCloseFailed) {
errorCode = -4;
} else {
doSomething; Facilite une programmation plus
}
errorCode = errorCode and -4;
} rigoureuse
}
} else { gestion des erreurs souvent négligée
errorCode = -5;
} par les programmeurs
return errorCode;
}

POO en Java 33 POO en Java 34

17
 26/05/2025

Exceptions I n terê t Exceptions Nouveautés à partir de Java7

⚫ Pouvoir propager les erreurs en remontant la pile des appels de méthodes
⚫ possibilité de mettre en œuvre une procédure de traitement de l'erreur à un niveau plus élevé que à l'endroit où
elle s'est produite
Approche « classique » (C) Avecles exceptions

method1() { method1() { method1( { ⚫ Java ajoute quelques nouveautés au langage Java pour faciliter la gestion des exceptions
int error = method2(); method2(); try {
if (error) proceed1(); method2();
doErrorProcessing(); } proceed1()
else } catch (Exception ex) { ⚫ récupération de plusieurs types d'exception dans un même bloc catch
proceed1(); method2 { doErrorProcessing();
} method3(); } ⚫ évite d'avoir à répéter des blocs catchs identiques pour des
}
int method2() { }
proceed2(); exceptions de types différents
int error = method3(); method2() throws Exception {
if (error) method3 { method3();
return error; proceed2();
else
readFile();
} ⚫ instruction "try-with-resources"
}
proceed2();
} seule method1 intéressée method3() throws Exception { ⚫ évite d'avoir un bloc finally pour la fermeture des ressources
par les erreurs pouvant readFile();
int method3() { intervenir dans readFile }
return readFile();
}
propagation automatique dans
on est contraint de forcer method2 et la pile des appels, seules les
method3 à propager les codes méthodes qui se soucient
d'erreur retournés par readFile des erreurs ont à les détecter
POO en Java 35 POO en Java 36

18
 26/05/2025

Exceptions At t raper plusieurs types d’exc ept ions Exceptions Ins truc tio n t r y av ec res s ourc es
⚫ Ressources : un objet qui doit être explicitement fermé lorsque le programme en a fini avec lui.
⚫ Exemples: fichier, connexion réseau…
⚫ Un simple bloc catch peut servir à gérer plusieurs types d’exception
⚫ Si l’utilisation des ressources peut provoquer des exceptions il faut soit
⚫ Réduit la duplication de code et diminue la tentation d'attraper une exception à l’aide d’un type trop
⚫ s’assurer explicitement de leur fermeture avec des clause finally
général. ⚫ déclarer la ou les ressources dans l’instruction try , la fermeture des ressources sera alors effectuée implicitement.

Exemple : copie d'un fichier vers un autre

try { try { try avec clauses finally Avec un try avec ressources
... ... static void copy(String src, String dest) throws IOException { static void copy(String src, String dest) throws IOException {
InputStream in = new FileInputStream(src); try (InputStream in = new FileInputStream(src);
try { OutputStream out = new FileOutputStream(dest)) {
} catch (IOException ex) { } catch (IOException | SQLException ex) OutputStream out = new FileOutputStream(dest); byte[] buf = new byte[8192];
[Link](ex); { [Link](ex); try { int n;
byte[] buf = new byte[8 * 1024]; while ((n = [Link](buf)) >= 0)
throw ex; throw ex; int n; [Link](buf, 0, n);
} } while ((n = [Link](buf)) >= 0) }
Duplication du code catch (SQLException ex) { [Link](buf, 0, n);
}
} finally {
[Link](ex); if (out != null) { un seul try sans clause finally (fermeture des fichiers est implicite)
throw ex; [Link]();
} }
} Les méthodes close des ressources sont appelées dans l’ordre inverse de leur création. Les
} finally {
if (in != null) { classes des ressources doivent implémenter l’interface [Link]
[Link]();
}
} InputStream, OutputStream, Reader, Writer ([Link]), Connection, Statement et
} ResultSet ([Link]) ont été ajustées (retrofitted)

2 try imbriqués chacun avec sa clause finally pour fermer le fichier

POO en Java 37 POO en Java 38

19
 26/05/2025

Exceptions I nst ruct ion try-avec-ressources Exceptions En résumé

Une instruction try avec resources peut avoir des blocs catch et finally tout comme une instruction try ordinaire.
⚫ les exceptions rendent la gestion des erreurs plus simple et plus lisible
public static void viewTable(Connection con) {

String query =
"select COF_NAME, SUP_ID, PRICE, SALES, TOTAL from COFFEES"; ⚫ lecode pour gérer les erreurs peut être regroupé en un seul endroit : là où on a besoin de
try ( Statement stmt = [Link]();
ResultSet rs = [Link](query) ) }
traiter l'erreur
while ([Link]()) {
String coffeeName = [Link]("COF_NAME");
int supplierID = [Link]("SUP_ID"); ⚫ possibilité de
se concentrer sur l'algorithme plutôt que de s'inquiéter à chaque instruction
try avec ressources
float price = [Link]("PRICE");
int sales = [Link]("SALES"); rs et stmt sont fermées de ce qui peut mal fonctionner,
int total = [Link]("TOTAL"); explicitement quoi qu'il
[Link](coffeeName + ", " + supplierID + ", " + price + arrive (exception ou pas)
", " + sales + ", " + total);
} ⚫ leserreurs remontent la hiérarchie d'appels grâce à l'exécutif du langage et non plus grâce
} à la bonne volonté des programmeurs.
catch (SQLException e) {
[Link](e); clause catch exécutée en
} cas de SQLException
}

Dans une instruction try avec resources les blocs catch et/ou finally sont exécutés après que les ressources
déclarées aient été implicitement fermées.
POO en Java 39 POO en Java 40

20