Java avancé : Gestion robuste des exceptions

Version mise à jour : Java moderne, architecture, tests et bonnes pratiques

Dr. Alla LO

Enseignant-Chercheur en IA & BI
Université Alioune Diop de Bambey

18 mai 2026

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 1 / 138
Présentation du chapitre

Ce chapitre aborde un aspect fondamental du développement Java avancé : la gestion des

exceptions.

Dans un programme réel, tout ne se passe pas toujours comme prévu. Un fichier peut être
absent, une donnée peut être invalide, une connexion peut échouer ou un utilisateur peut saisir
une valeur incorrecte.

Idée centrale
La gestion des exceptions permet de construire des applications plus fiables, plus lisibles et
plus faciles à maintenir.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 2 / 138
Objectif général du chapitre

Objectif général
À la fin de ce chapitre, l’étudiant doit être capable de comprendre le mécanisme des exceptions
en Java, de choisir la bonne stratégie de traitement des erreurs, de créer des exceptions
personnalisées et d’intégrer ces pratiques dans des applications orientées objet réalistes.

Ce chapitre ne se limite pas à la syntaxe try/catch. Il vise aussi à développer une bonne
manière de penser la robustesse logicielle.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 3 / 138
Objectifs spécifiques

À la fin de ce chapitre, l’étudiant devra être capable de :

expliquer ce qu’est une exception et pourquoi elle est utile ;
distinguer erreur utilisateur, erreur métier, erreur technique et erreur de programmation ;
comprendre la hiérarchie Throwable, Error, Exception, RuntimeException ;
différencier les exceptions vérifiées et non vérifiées ;
utiliser correctement try, catch, finally, throw et throws ;
appliquer try-with-resources pour fermer automatiquement les ressources ;
concevoir des exceptions métier adaptées au domaine de l’application ;
éviter les mauvaises pratiques fréquentes.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 4 / 138
Plan détaillé du chapitre
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 5 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 6 / 138
Un programme réel est exposé à des imprévus

Un programme informatique interagit souvent avec un environnement extérieur : utilisateurs,

fichiers, réseau, base de données, périphériques, API, etc.
Ces éléments ne sont pas toujours fiables ou prévisibles.
Exemples :
l’utilisateur saisit une chaîne de caractères au lieu d’un nombre ;
le fichier demandé a été supprimé ;
la base de données ne répond plus ;
la connexion Internet est interrompue ;
une méthode reçoit un paramètre incohérent ;
une opération mathématique impossible est demandée.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 7 / 138
Conséquence d’une erreur non gérée

Lorsqu’une erreur n’est pas correctement gérée, plusieurs conséquences sont possibles :
arrêt brutal du programme ;
affichage d’un message incompréhensible pour l’utilisateur ;
perte de données ;
comportement incohérent ;
difficulté pour le développeur à comprendre l’origine du problème ;
faille de sécurité si des informations techniques sensibles sont affichées.

Point important
Un programme robuste n’est pas un programme qui n’a jamais d’erreur. C’est un programme
qui sait réagir correctement lorsqu’une erreur survient.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 8 / 138
Exemple simple : saisie d’un âge

Imaginons un programme qui demande l’âge d’un utilisateur.

Cas possibles :
l’utilisateur saisit 25 : tout va bien ;
l’utilisateur saisit abc : conversion impossible ;
l’utilisateur saisit -5 : valeur numérique mais incohérente ;
l’utilisateur ne saisit rien : donnée absente.

Analyse
Toutes ces situations ne doivent pas être traitées de la même façon. Certaines relèvent d’un
simple contrôle de saisie, d’autres d’une exception.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 9 / 138
Le rôle des exceptions

Les exceptions permettent de :

signaler qu’un problème empêche la poursuite normale du traitement ;
séparer le code métier du code de gestion d’erreurs ;
transmettre une erreur à une méthode appelante ;
fournir un message et une trace utiles au diagnostic ;
traiter différemment plusieurs types d’erreurs.

Exemple d’idée
Une méthode de retrait bancaire peut signaler que le solde est insuffisant sans décider
elle-même comment informer l’utilisateur final.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 10 / 138
Sans exceptions : code mélangé

Sans mécanisme d’exception, on est souvent obligé de tester constamment les retours des
fonctions.
Cela peut donner un code :
plus long ;
plus difficile à lire ;
plus fragile ;
où les erreurs sont facilement oubliées ;
où le code métier est noyé dans les tests techniques.

Apport de Java
Java propose un système structuré pour représenter, lever, propager et capturer les erreurs.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 11 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 12 / 138
Définition d’une exception

Définition
Une exception est un objet qui représente une situation anormale survenue pendant l’exécution
d’un programme.

Une exception contient généralement :

un type, par exemple IOException ;
un message décrivant le problème ;
une pile d’appels, appelée stack trace ;
éventuellement une cause initiale.

À retenir
En Java, une exception n’est pas seulement un message : c’est un véritable objet.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 13 / 138
Erreur, exception et bug : ne pas confondre

Terme Sens
Erreur utilisateur Mauvaise saisie ou action incorrecte de l’utilisa-
teur.
Exception Signal produit pendant l’exécution pour indiquer
un problème.
Bug Défaut dans la logique ou l’implémentation du pro-
gramme.
Erreur système Problème grave venant de l’environnement : mé-
moire, JVM, système.

Remarque
Une exception peut être causée par un bug, mais toutes les exceptions ne sont pas forcément
des bugs.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 14 / 138
Exemple : une même erreur, plusieurs lectures

Une conversion impossible peut avoir plusieurs significations.

Exemple :
l’utilisateur a saisi abc dans un champ âge ;
un fichier CSV contient une valeur non numérique dans une colonne montant ;
une API externe renvoie une donnée inattendue.

Conséquence
Le traitement doit dépendre du contexte : afficher un message à l’utilisateur, ignorer une ligne
invalide, arrêter l’importation, journaliser l’erreur, etc.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 15 / 138
La pile d’appels : stack trace

Lorsqu’une exception apparaît, Java produit souvent une trace appelée stack trace.
Cette trace indique :
le type de l’exception ;
le message associé ;
la méthode où l’erreur est apparue ;
la chaîne des méthodes appelantes ;
les numéros de ligne concernés.

Intérêt
La stack trace est très utile pour le développeur, car elle permet de retrouver l’origine d’une
erreur.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 16 / 138
 Exemple de stack trace

1 Exception in thread "main" [Link] : / by zero

2 at [Link]([Link] :5)
3 at [Link]([Link] :10)

Lecture :
le type est ArithmeticException ;
le message est / by zero ;
l’erreur est apparue dans [Link], ligne 5 ;
cette méthode a été appelée depuis [Link], ligne 10.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 17 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 18 / 138
Toutes les exceptions héritent de Throwable

En Java, la hiérarchie des erreurs commence avec la classe Throwable.

Deux grandes familles héritent de Throwable :
Error ;
Exception.

Idée importante
Même si Error et Exception héritent toutes les deux de Throwable, elles n’ont pas le même
rôle et ne doivent pas être traitées de la même façon.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 19 / 138
Schéma simplifié de la hiérarchie

Throwable

Error Exception

Exceptions RuntimeException
vérifiées non vérifiées

Lecture
Les exceptions vérifiées sont les exceptions qui héritent de Exception mais pas de
RuntimeException.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 20 / 138
La classe Error

Error représente des problèmes graves, souvent liés à la machine virtuelle Java ou au système.
Exemples :
OutOfMemoryError : mémoire insuffisante ;
StackOverflowError : pile d’appels saturée ;
VirtualMachineError : problème grave de JVM.

Bonne pratique
Dans une application métier classique, on ne capture généralement pas les Error. Elles
signalent souvent un état trop grave pour être corrigé localement.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 21 / 138
La classe Exception

Exception représente des problèmes que l’application peut souvent anticiper, traiter ou
propager.
Exemples :
fichier introuvable ;
erreur d’entrée/sortie ;
classe introuvable ;
problème SQL ;
règle métier non respectée.

À retenir
C’est la famille principale utilisée par le développeur pour représenter les erreurs applicatives.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 22 / 138
Exceptions vérifiées et non vérifiées

Checked exceptions
Unchecked exceptions
Le compilateur oblige à les gérer ou à les
Le compilateur n’oblige pas à les gérer.
déclarer.
Exemples :
Exemples :
NullPointerException
IOException
IllegalArgumentException
SQLException
ArithmeticException
ClassNotFoundException

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 23 / 138
Comment choisir ?
Situation Choix généralement adapté
L’appelant peut raison- Exception vérifiée
nablement corriger ou ré-
essayer
Le problème vient d’un Exception non vérifiée
mauvais paramètre ou
d’un mauvais état interne
Une règle métier impor- Exception personnalisée, selon le style du
tante est violée projet
Une ressource externe est Exception vérifiée ou encapsulation dans une
indisponible exception applicative

Conseil
Le choix dépend aussi de l’architecture du projet. L’essentiel est d’être cohérent.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 24 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 25 / 138
Le bloc try

Le bloc try contient le code susceptible de provoquer une exception.

Il ne signifie pas que l’erreur va forcément se produire. Il signifie seulement que le
programmeur reconnaît qu’une erreur est possible.

Exemples de code risqué

lire un fichier ;
convertir une chaîne en nombre ;
accéder à une base de données ;
appeler une API distante ;
manipuler un tableau avec un indice calculé.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 26 / 138
 Structure générale

1 try {
2 // Code susceptible de provoquer une exception
3 } catch (TypeException e) {
4 // Traitement de cette exception
5 } finally {
6 // Code execute dans tous les cas
7 }

try : zone surveillée ;

catch : réaction à une exception donnée ;
finally : nettoyage exécuté dans presque tous les cas.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 27 / 138
 Exemple 1 : division par zéro

1 public class DivisionDemo {

2 public static void main(String[] args) {
3 int a = 10;
4 int b = 0;
5
6 try {
7 int resultat = a / b ;
8 [Link]("Resultat = " + resultat) ;
9 } catch (ArithmeticException e) {
10 [Link]("Erreur : division par zero impossible.") ;
11 }
12
13 [Link]("Fin du programme.") ;
14 }
15 }

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 28 / 138
Explication de l’exemple de division

Dans cet exemple, l’instruction a / b provoque une exception car b vaut zéro.
Java crée alors un objet de type ArithmeticException. Comme cette exception correspond
au type indiqué dans le bloc catch, le programme exécute ce bloc.

Conséquence
Le programme ne s’arrête pas brutalement. Il affiche un message compréhensible puis continue
son exécution.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 29 / 138
 Exemple 2 : conversion d’une chaîne

1 public class ConversionDemo {

2 public static void main(String[] args) {
3 String valeur = "12a" ;
4
5 try {
6 int age = [Link](valeur) ;
7 [Link]("Age = " + age) ;
8 } catch (NumberFormatException e) {
9 [Link]("La valeur saisie n’est pas un entier valide.") ;
10 }
11 }
12 }

Méthode risquée
[Link]() peut échouer si la chaîne ne représente pas correctement un nombre
entier.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 30 / 138
Explication de l’exemple de conversion

La chaîne "12a" contient une lettre. Elle ne peut donc pas être convertie en entier.
Java lève alors une NumberFormatException.

Analyse pédagogique
Cette erreur est fréquente dans les programmes qui lisent des données saisies au clavier, des
fichiers CSV ou des formulaires web.

Bonne pratique
Lorsque les données viennent d’un utilisateur ou d’une source externe, il faut toujours prévoir
qu’elles peuvent être invalides.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 31 / 138
 Plusieurs blocs catch

1 try {
2 String[] noms = {"Awa", "Moussa"} ;
3 [Link](noms[3]) ;
4
5 int x = [Link]("abc") ;
6
7 } catch (ArrayIndexOutOfBoundsException e) {
8 [Link]("Indice de tableau invalide.") ;
9 } catch (NumberFormatException e) {
10 [Link]("Format numerique invalide.") ;
11 } catch (Exception e) {
12 [Link]("Erreur generale : " + [Link]()) ;
13 }

Objectif
Traiter chaque type d’erreur avec un message ou une réaction adaptée.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 32 / 138
Ordre des catch

L’ordre des blocs catch est important.

Java teste les blocs catch de haut en bas. Le premier bloc compatible avec l’exception est
exécuté.

Règle d’or
Il faut placer les exceptions les plus spécifiques avant les exceptions plus générales.

Exemple :
NumberFormatException avant RuntimeException ;
IOException avant Exception ;
FileNotFoundException avant IOException.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 33 / 138
 Mauvais ordre des catch

1 try {
2 int x = [Link]("abc") ;
3 } catch (Exception e) {
4 [Link]("Erreur generale") ;
5 } catch (NumberFormatException e) {
6 [Link]("Format invalide") ;
7 }

Erreur de compilation
Le bloc catch (NumberFormatException e) est inaccessible, car NumberFormatException
est déjà couverte par Exception.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 34 / 138
Le bloc finally

Le bloc finally sert à exécuter du code à la fin du traitement, qu’une exception ait été levée
ou non.
Usages courants :
fermer un fichier ;
libérer une connexion ;
supprimer un fichier temporaire ;
remettre une variable ou un état dans une situation propre ;
afficher une trace de fin de traitement.

À retenir
Le finally est surtout utile pour le nettoyage.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 35 / 138
 Exemple avec finally

1 public class FinallyDemo {

2 public static void main(String[] args) {
3 try {
4 [Link]("Debut du traitement") ;
5 int x = 10 / 0;
6 } catch (ArithmeticException e) {
7 [Link]("Erreur de calcul") ;
8 } finally {
9 [Link]("Fin du traitement") ;
10 }
11 }
12 }

Observation
Même si la division échoue, le message "Fin du traitement" est affiché.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 36 / 138
 Piège : return dans finally

1 public static int calculer() {

2 try {
3 return 1;
4 } finally {
5 return 2;
6 }
7 }

Problème
Le return du bloc finally écrase la valeur retournée par le bloc try. Le résultat sera donc
2, pas 1.

Bonne pratique
Éviter return, break, continue et les nouvelles exceptions dans finally.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 37 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 38 / 138
Différence entre throw et throws

Mot-clé Rôle
throw Lance explicitement une exception dans le corps
d’une méthode.
throws Déclare dans la signature d’une méthode que celle-
ci peut transmettre une exception.

Image simple
throw signifie : “je déclenche l’exception maintenant”.
throws signifie : “cette méthode peut échouer et transmettre l’exception à l’appelant”.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 39 / 138
 Exemple avec throw

1 public static void verifierAge(int age) {

2 if (age < 0) {
3 throw new IllegalArgumentException("L’age ne peut pas etre negatif") ;
4 }
5 [Link]("Age valide : " + age) ;
6 }

Explication
La méthode refuse de continuer si l’âge est négatif. Elle signale immédiatement que le
paramètre reçu est incorrect.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 40 / 138
Pourquoi utiliser IllegalArgumentException ?

IllegalArgumentException est adaptée lorsqu’une méthode reçoit un argument invalide.

Exemples :
âge négatif ;
prix inférieur à zéro ;
taux de réduction supérieur à 100 % ;
quantité commandée inférieure ou égale à zéro ;
nom obligatoire mais vide.

Idée
Cette exception signale généralement une mauvaise utilisation de la méthode.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 41 / 138
 Exemple avec throws

1 import [Link].* ;
2
3 public class LectureFichier {
4 public static String lirePremiereLigne(String chemin) throws IOException {
5 BufferedReader br = new BufferedReader(new FileReader(chemin)) ;
6 String ligne = [Link]() ;
7 [Link]() ;
8 return ligne ;
9 }
10 }

Explication
La méthode ne traite pas elle-même l’erreur. Elle oblige l’appelant à la gérer ou à la propager à
son tour.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 42 / 138
La propagation des exceptions

Lorsqu’une méthode ne capture pas une exception, celle-ci remonte vers la méthode appelante.
Ce mécanisme s’appelle la propagation.

Exemple conceptuel
main() appelle service(), qui appelle repository(), qui appelle la base de données. Si la
base échoue, l’exception peut remonter jusqu’à main() ou jusqu’à une couche chargée de la
gérer.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 43 / 138
 Exemple de propagation

1 public static void niveau3() throws Exception {

2 throw new Exception("Erreur au niveau 3") ;
3 }
4
5 public static void niveau2() throws Exception {
6 niveau3() ;
7 }
8
9 public static void niveau1() {
10 try {
11 niveau2() ;
12 } catch (Exception e) {
13 [Link]("Exception capturee : " + [Link]()) ;
14 }
15 }

Lecture
L’exception naît dans niveau3, traverse niveau2, puis est capturée dans niveau1.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 44 / 138
Traiter ou propager ?

Une question importante est : faut-il traiter l’exception ici ou la propager ?

Traiter localement si...

La méthode sait quoi faire : afficher un message, utiliser une valeur par défaut, réessayer,
fermer une ressource.

Propager si...
La méthode ne sait pas prendre une décision correcte. Dans ce cas, elle laisse une couche
supérieure décider.

Règle pratique
Il vaut mieux propager une exception que la capturer inutilement sans traitement réel.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 45 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 46 / 138
Exceptions vérifiées : principe

Une exception vérifiée est contrôlée par le compilateur.

Si une méthode peut lever une exception vérifiée, Java oblige le développeur à choisir :
capturer l’exception avec try/catch ;
ou la déclarer avec throws.

Objectif
Le compilateur force le développeur à ne pas ignorer certains problèmes considérés comme
importants ou prévisibles.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 47 / 138
Exemples d’exceptions vérifiées

Exception Situation typique

IOException Erreur d’entrée/sortie : fichier, flux, réseau.
FileNotFoundException Fichier introuvable.
SQLException Problème d’accès à une base de données.
ClassNotFoundExceptionClasse chargée dynamiquement introuvable.

Point commun
Ces erreurs concernent souvent des ressources externes au programme.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 48 / 138
Exceptions non vérifiées : principe

Les exceptions non vérifiées héritent de RuntimeException.

Le compilateur n’impose pas de les capturer ni de les déclarer.
Elles représentent souvent :
une erreur de programmation ;
un mauvais argument ;
un objet non initialisé ;
une hypothèse fausse dans le code ;
une violation d’état interne.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 49 / 138
Exemples d’exceptions non vérifiées

Exception Situation typique

NullPointerException Utilisation d’une référence null.
ArithmeticException Division entière par zéro.
Indice invalide dans une liste ou un tableau.
IndexOutOfBoundsException
Paramètre invalide fourni à une méthode.
IllegalArgumentException
IllegalStateException Méthode appelée alors que l’objet est dans
un mauvais état.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 50 / 138
 Exemple : IllegalArgumentException

1 public class ProduitService {

2 public double appliquerReduction(double prix, double taux) {
3 if (prix < 0) {
4 throw new IllegalArgumentException("Le prix ne peut pas etre negatif") ;
5 }
6 if (taux < 0 || taux > 1) {
7 throw new IllegalArgumentException("Le taux doit etre entre 0 et 1") ;
8 }
9 return prix * (1 - taux) ;
10 }
11 }

Analyse
Un prix négatif ou un taux hors intervalle indique que la méthode est appelée avec de
mauvaises données.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 51 / 138
Faut-il capturer les RuntimeException ?

En général, il ne faut pas capturer systématiquement toutes les RuntimeException.

Pourquoi ?
elles signalent souvent une erreur de programmation ;
les capturer peut masquer un bug ;
il vaut parfois mieux corriger la cause plutôt que traiter la conséquence.

Exemple
Si un objet est null, il vaut mieux comprendre pourquoi il est null plutôt que capturer
partout NullPointerException.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 52 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 53 / 138
Qu’est-ce qu’une ressource ?
Une ressource est un objet qui utilise un élément externe ou coûteux et qui doit être fermé
après utilisation.
Exemples :
fichier ouvert ;
flux d’entrée ou de sortie ;
connexion réseau ;
connexion à une base de données ;
scanner lié à un fichier ;
socket.

Risque
Si une ressource n’est pas fermée, elle peut provoquer des fuites de ressources, des fichiers
verrouillés ou des connexions saturées.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 54 / 138
 Ancienne approche avec finally

1 BufferedReader br = null ;
2 try {
3 br = new BufferedReader(new FileReader("[Link]")) ;
4 String ligne = [Link]() ;
5 [Link](ligne) ;
6 } catch (IOException e) {
7 [Link]("Erreur de lecture") ;
8 } finally {
9 try {
10 if (br != null) [Link]() ;
11 } catch (IOException e) {
12 [Link]("Erreur lors de la fermeture") ;
13 }
14 }

Limite
Le code est long, répétitif et difficile à maintenir.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 55 / 138
 Approche moderne : try-with-resources

1 import [Link].* ;
2
3 public class LectureNotes {
4 public static void main(String[] args) {
5 try (BufferedReader br = new BufferedReader(new FileReader("[Link]"))) {
6 String ligne ;
7 while ((ligne = [Link]()) != null) {
8 [Link](ligne) ;
9 }
10 } catch (IOException e) {
11 [Link]("Impossible de lire le fichier : " + [Link]()) ;
12 }
13 }
14 }

Avantage
La ressource est fermée automatiquement, même si une exception apparaît.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 56 / 138
Pourquoi try-with-resources est préférable ?

le code est plus court ;

la fermeture est automatique ;
le risque d’oubli est réduit ;
le code est plus lisible ;
plusieurs ressources peuvent être ouvertes dans le même bloc ;
Java gère mieux les exceptions qui apparaissent pendant la fermeture.

Condition
La ressource doit implémenter AutoCloseable ou Closeable.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 57 / 138
 Plusieurs ressources dans le même try

1 try (
2 BufferedReader br = new BufferedReader(new FileReader("[Link]")) ;
3 PrintWriter pw = new PrintWriter(new FileWriter("[Link]"))
4 ) {
5 String ligne ;
6 while ((ligne = [Link]()) != null) {
7 [Link]([Link]()) ;
8 }
9 } catch (IOException e) {
10 [Link]("Erreur E/S : " + [Link]()) ;
11 }

Lecture
Le fichier d’entrée et le fichier de sortie sont fermés automatiquement à la fin du bloc.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 58 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 59 / 138
Pourquoi créer ses propres exceptions ?

Les exceptions standards de Java décrivent bien les erreurs techniques, mais elles ne décrivent
pas toujours clairement les erreurs métier.
Exemples d’erreurs métier :
retrait impossible car solde insuffisant ;
inscription refusée car la classe est pleine ;
commande impossible car le stock est insuffisant ;
note invalide car elle dépasse 20 ;
réservation impossible car la date est déjà occupée.

Intérêt
Une exception personnalisée donne un vocabulaire clair au programme.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 60 / 138
Exception technique ou exception métier ?

Type Exemple
Exception technique Fichier absent, base inaccessible, erreur ré-
seau.
Exception métier Solde insuffisant, module complet, stock in-
suffisant.

Différence
Une exception technique vient souvent de l’infrastructure. Une exception métier vient d’une
règle du domaine étudié.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 61 / 138
 Exception métier vérifiée

1 public class SoldeInsuffisantException extends Exception {

2 public SoldeInsuffisantException(String message) {
3 super(message) ;
4 }
5
6 public SoldeInsuffisantException(String message, Throwable cause) {
7 super(message, cause) ;
8 }
9 }

Effet
Comme elle hérite de Exception, le compilateur oblige à la traiter ou à la déclarer.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 62 / 138
 Exception métier non vérifiée

1 public class ProduitIndisponibleException extends RuntimeException {

2 public ProduitIndisponibleException(String message) {
3 super(message) ;
4 }
5 }

Effet
Comme elle hérite de RuntimeException, le compilateur n’oblige pas à la traiter.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 63 / 138
Quelle forme choisir ?

Il n’y a pas une seule réponse universelle.

Exception vérifiée
Utile lorsque l’appelant doit explicitement gérer le cas : afficher un message, proposer une
alternative, demander une confirmation.

Exception non vérifiée

Utile lorsque l’erreur représente une violation de règle interne ou lorsqu’on ne veut pas alourdir
toutes les signatures.

Conseil
Dans un cours, il est intéressant de montrer les deux approches et d’expliquer le choix.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 64 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 65 / 138
Contexte de l’étude de cas

On souhaite modéliser un compte bancaire simple.

Règles :
le solde initial ne peut pas être négatif ;
un dépôt doit avoir un montant positif ;
un retrait doit avoir un montant positif ;
un retrait ne peut pas dépasser le solde disponible.

Analyse
Certaines erreurs relèvent d’un mauvais paramètre. D’autres relèvent d’une règle métier
bancaire.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 66 / 138
 Exception métier : solde insuffisant

1 public class SoldeInsuffisantException extends Exception {

2 public SoldeInsuffisantException(String message) {
3 super(message) ;
4 }
5 }

Pourquoi une exception spécifique ?

Le solde insuffisant est une règle métier importante. Elle mérite un type d’exception clair.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 67 / 138
 Classe CompteBancaire
1 public class CompteBancaire {
2 private double solde ;
3
4 public CompteBancaire(double soldeInitial) {
5 if (soldeInitial < 0) {
6 throw new IllegalArgumentException("Solde initial invalide") ;
7 }
8 [Link] = soldeInitial ;
9 }
10
11 public void deposer(double montant) {
12 if (montant <= 0) {
13 throw new IllegalArgumentException("Le montant doit etre positif") ;
14 }
15 solde += montant ;
16 }
17
18 public double getSolde() {
19 return solde ;
20 }
21 } . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 68 / 138
 Ajout de la méthode retirer

1 public void retirer(double montant) throws SoldeInsuffisantException {

2 if (montant <= 0) {
3 throw new IllegalArgumentException("Le montant doit etre positif") ;
4 }
5
6 if (montant > solde) {
7 throw new SoldeInsuffisantException(
8 "Retrait impossible : solde insuffisant") ;
9 }
10
11 solde -= montant ;
12 }

Lecture
Un montant négatif est une erreur d’appel. Un solde insuffisant est une règle métier.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 69 / 138
 Programme principal

1 public class MainBanque {

2 public static void main(String[] args) {
3 CompteBancaire compte = new CompteBancaire(100000) ;
4
5 try {
6 [Link](150000) ;
7 [Link]("Retrait effectue") ;
8 } catch (SoldeInsuffisantException e) {
9 [Link]("Operation refusee : " + [Link]()) ;
10 } catch (IllegalArgumentException e) {
11 [Link]("Donnee invalide : " + [Link]()) ;
12 }
13
14 [Link]("Solde final = " + [Link]()) ;
15 }
16 }

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 70 / 138
Analyse de l’étude de cas bancaire

Cette étude de cas permet de comprendre plusieurs points importants :

les exceptions peuvent représenter des règles métier ;
toutes les erreurs ne doivent pas être traitées de la même manière ;
IllegalArgumentException est adaptée aux paramètres invalides ;
une exception personnalisée améliore la lisibilité ;
le bloc catch peut afficher un message adapté à l’utilisateur.

Message pédagogique
Une bonne exception doit aider à comprendre le problème, pas seulement arrêter le programme.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 71 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 72 / 138
Contexte

On souhaite développer une application permettant d’inscrire des étudiants dans un module.
Règles métier :
le nom de l’étudiant est obligatoire ;
l’âge minimum est 16 ans ;
chaque module a une capacité maximale ;
si le module est plein, l’inscription est refusée.

Objectif pédagogique
Montrer comment combiner validation des données, exception non vérifiée et exception métier
vérifiée.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 73 / 138
 Exception InscriptionException

1 public class InscriptionException extends Exception {

2 public InscriptionException(String message) {
3 super(message) ;
4 }
5 }

Rôle
Cette exception représente un échec d’inscription lié aux règles du module.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 74 / 138
 Classe Etudiant

1 public class Etudiant {

2 private String nom ;
3 private int age ;
4
5 public Etudiant(String nom, int age) {
6 if (nom == null || [Link]()) {
7 throw new IllegalArgumentException("Le nom est obligatoire") ;
8 }
9 if (age < 16) {
10 throw new IllegalArgumentException("L’age minimum est 16 ans") ;
11 }
12 [Link] = nom ;
13 [Link] = age ;
14 }
15
16 public String getNom() { return nom ; }
17 public int getAge() { return age ; }
18 }

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 75 / 138
Analyse de la classe Etudiant

Dans cette classe, les contrôles sont effectués dans le constructeur.

Pourquoi ?
pour empêcher la création d’un objet invalide ;
pour garantir que tout objet Etudiant a un nom correct ;
pour garantir que tout étudiant a un âge acceptable ;
pour éviter de répéter les mêmes vérifications partout.

Principe objet
Un objet doit protéger sa propre cohérence interne.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 76 / 138
 Classe Module
1 import [Link] ;
2 import [Link] ;
3
4 public class Module {
5 private String intitule ;
6 private int capaciteMax ;
7 private List<Etudiant> inscrits = new ArrayList<>() ;
8
9 public Module(String intitule, int capaciteMax) {
10 [Link] = intitule ;
11 [Link] = capaciteMax ;
12 }
13
14 public void inscrire(Etudiant e) throws InscriptionException {
15 if ([Link]() >= capaciteMax) {
16 throw new InscriptionException("Module complet : " + intitule) ;
17 }
18 [Link](e) ;
19 }
20 }
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 77 / 138
 Programme principal

1 public class MainInscription {

2 public static void main(String[] args) {
3 Module javaAvance = new Module("Java avance", 1) ;
4
5 try {
6 [Link](new Etudiant("Awa", 20)) ;
7 [Link](new Etudiant("Moussa", 21)) ;
8 } catch (InscriptionException e) {
9 [Link]("Inscription refusee : " + [Link]()) ;
10 } catch (IllegalArgumentException e) {
11 [Link]("Donnee invalide : " + [Link]()) ;
12 }
13 }
14 }

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 78 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 79 / 138
Encapsuler une exception

Parfois, une méthode reçoit une exception technique, mais veut exposer une exception plus
compréhensible pour le reste de l’application.
Exemple :
une méthode d’accès aux données reçoit une SQLException ;
elle peut la transformer en ClientRepositoryException ;
elle doit conserver la cause initiale.

But
Ne pas exposer partout les détails techniques, tout en gardant les informations utiles au
diagnostic.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 80 / 138
 Conserver la cause initiale

1 public class ClientRepositoryException extends Exception {

2 public ClientRepositoryException(String message, Throwable cause) {
3 super(message, cause) ;
4 }
5 }
6
7 public Client chercherClient(int id) throws ClientRepositoryException {
8 try {
9 // Acces a la base de donnees
10 return null ;
11 } catch (Exception e) {
12 throw new ClientRepositoryException(
13 "Impossible de charger le client " + id, e) ;
14 }
15 }

Bonne pratique
Utiliser super(message, cause) pour ne pas perdre l’exception d’origine.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 81 / 138
Journaliser les erreurs

Journaliser signifie enregistrer les événements importants de l’application.

On peut journaliser :
une erreur critique ;
un avertissement ;
une information utile ;
une tentative de connexion ;
une exception avec sa stack trace.

Important
Afficher un message avec [Link]() peut être acceptable en apprentissage,
mais dans un projet réel on utilise un système de logs.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 82 / 138
 Exemple avec [Link]

1 import [Link] ;
2 import [Link] ;
3
4 public class ServiceClient {
5 private static final Logger LOGGER =
6 [Link]([Link]()) ;
7
8 public void traiter() {
9 try {
10 int x = [Link]("abc") ;
11 } catch (NumberFormatException e) {
12 [Link]([Link], "Format numerique invalide", e) ;
13 }
14 }
15 }

Intérêt
Le log conserve le message, le niveau de gravité et la trace technique.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 83 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 84 / 138
Bonnes pratiques principales

1 Capturer les exceptions les plus spécifiques possible.

2 Ne jamais écrire un bloc catch vide.
3 Ne pas capturer une exception si on ne sait pas quoi faire.
4 Conserver la cause initiale lors d’une encapsulation.
5 Utiliser try-with-resources pour les ressources.
6 Écrire des messages d’erreur clairs.
7 Séparer erreurs techniques et erreurs métier.
8 Ne pas utiliser les exceptions comme mécanisme normal de boucle.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 85 / 138
 Mauvaise pratique : catch vide

1 try {
2 int age = [Link](saisie) ;
3 } catch (NumberFormatException e) {
4 // Rien du tout
5 }

Problème
L’erreur disparaît silencieusement. Le programme peut continuer avec un état incorrect et le
développeur aura du mal à diagnostiquer le problème.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 86 / 138
 Meilleure version

1 try {
2 int age = [Link](saisie) ;
3 } catch (NumberFormatException e) {
4 [Link]("Veuillez saisir un age numerique valide.") ;
5 }

Encore mieux
Dans une application réelle : afficher un message simple à l’utilisateur et journaliser le détail
technique pour le développeur.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 87 / 138
 Mauvaise pratique : capturer Exception partout

1 try {
2 effectuerTraitement() ;
3 } catch (Exception e) {
4 [Link]("Une erreur est survenue") ;
5 }

Problème
On ne sait pas quel problème s’est réellement produit. On risque de masquer une erreur grave
ou une erreur de programmation.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 88 / 138
Règles de décision simples

Question Décision possible

Puis-je corriger le problème ici ? Capturer et traiter.
La couche actuelle ne sait pas Propager.
quoi faire ?
Le problème vient d’un mauvais Lever IllegalArgumentException.
paramètre ?
Le problème correspond à une Créer une exception métier.
règle métier ?
Une ressource doit être fermée ? Utiliser try-with-resources.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 89 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 90 / 138
Exercice 1 : lecture de code

On donne la situation suivante : un tableau contient trois notes, mais le programme essaie
d’afficher la quatrième.
Questions :
1 Quelle exception peut apparaître ?
2 Pourquoi cette exception apparaît-elle ?
3 Proposer une correction avec try/catch.
4 Proposer une meilleure correction sans exception.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 91 / 138
 Correction avec try/catch

1 public class Exercice1 {

2 public static void main(String[] args) {
3 double[] notes = {12.5, 14.0, 9.5} ;
4
5 try {
6 [Link](notes[3]) ;
7 } catch (ArrayIndexOutOfBoundsException e) {
8 [Link]("Indice invalide. Taille = " + [Link]) ;
9 }
10 }
11 }

Explication
Les indices valides sont 0, 1 et 2. L’indice 3 n’existe pas.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 92 / 138
 Correction préférable avec test

1 int indice = 3;
2 double[] notes = {12.5, 14.0, 9.5} ;
3
4 if (indice >= 0 && indice < [Link]) {
5 [Link](notes[indice]) ;
6 } else {
7 [Link]("Indice invalide") ;
8 }

Pourquoi cette version est meilleure ?

Ici, l’indice invalide est une situation prévisible. Un simple test est donc plus clair qu’une
exception.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 93 / 138
Exercice 2 : validation d’une note

Écrire une méthode verifierNote(double note) qui respecte les règles suivantes :
une note doit être comprise entre 0 et 20 ;
si la note est invalide, lever une IllegalArgumentException ;
si la note est valide, afficher "Note valide".

Objectif
Savoir utiliser une exception non vérifiée pour signaler un mauvais paramètre.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 94 / 138
 Correction exercice 2

1 public static void verifierNote(double note) {

2 if (note < 0 || note > 20) {
3 throw new IllegalArgumentException("La note doit etre entre 0 et 20") ;
4 }
5 [Link]("Note valide") ;
6 }

Explication
Une note hors intervalle indique que la méthode reçoit une valeur incorrecte.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 95 / 138
Mini-TP : gestion d’un stock

On souhaite développer une petite application de gestion de stock.

Travail demandé :
1 Créer une classe Produit avec nom, prix et quantité.
2 Interdire un prix négatif.
3 Interdire une quantité négative.
4 Créer une exception StockInsuffisantException.
5 Écrire une méthode vendre(int quantiteDemandee).
6 Tester le programme avec plusieurs ventes.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 96 / 138
 Correction mini-TP : exception

1 public class StockInsuffisantException extends Exception {

2 public StockInsuffisantException(String message) {
3 super(message) ;
4 }
5 }

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 97 / 138
 Correction mini-TP : classe Produit
1 public class Produit {
2 private String nom ;
3 private double prix ;
4 private int quantite ;
5
6 public Produit(String nom, double prix, int quantite) {
7 if (nom == null || [Link]()) {
8 throw new IllegalArgumentException("Nom obligatoire") ;
9 }
10 if (prix < 0) {
11 throw new IllegalArgumentException("Prix negatif interdit") ;
12 }
13 if (quantite < 0) {
14 throw new IllegalArgumentException("Quantite negative interdite") ;
15 }
16 [Link] = nom ;
17 [Link] = prix ;
18 [Link] = quantite ;
19 }
20 }
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 98 / 138
 Correction mini-TP : méthode vendre

1 public void vendre(int quantiteDemandee) throws StockInsuffisantException {

2 if (quantiteDemandee <= 0) {
3 throw new IllegalArgumentException(
4 "La quantite demandee doit etre positive") ;
5 }
6
7 if (quantiteDemandee > quantite) {
8 throw new StockInsuffisantException(
9 "Stock insuffisant pour le produit " + nom) ;
10 }
11
12 quantite -= quantiteDemandee ;
13 }

Analyse
La quantité négative est une erreur de paramètre. Le stock insuffisant est une erreur métier.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 99 / 138
 Correction mini-TP : programme principal

1 public class MainStock {

2 public static void main(String[] args) {
3 Produit riz = new Produit("Riz parfume", 18000, 10) ;
4
5 try {
6 [Link](4) ;
7 [Link](8) ;
8 [Link]("Ventes effectuees") ;
9 } catch (StockInsuffisantException e) {
10 [Link]("Vente impossible : " + [Link]()) ;
11 } catch (IllegalArgumentException e) {
12 [Link]("Donnee invalide : " + [Link]()) ;
13 }
14 }
15 }

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 100 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 101 / 138
Pourquoi parler de Java moderne ?
Le mécanisme général des exceptions existe depuis les premières versions de Java, mais
certaines pratiques ont évolué.
Aujourd’hui, un développeur Java doit savoir :
fermer automatiquement les ressources avec try-with-resources ;
regrouper certains traitements avec multi-catch ;
conserver la cause initiale d’une exception ;
éviter les messages techniques exposés à l’utilisateur ;
tester les cas d’erreur avec des tests unitaires ;
écrire du code lisible et maintenable, pas seulement du code qui compile.

Message pédagogique
Une bonne gestion d’exception fait partie de la qualité du logiciel, au même titre que la
lisibilité, les tests et l’architecture.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 102 / 138
 Le multi-catch
Depuis Java 7, il est possible de capturer plusieurs types d’exceptions dans un même bloc
catch lorsque le traitement est identique.
1 try {
2 int age = [Link](saisieAge) ;
3 double prix = [Link](saisiePrix) ;
4 } catch (NumberFormatException | NullPointerException e) {
5 [Link]("Une valeur obligatoire est absente ou invalide.") ;
6 }

Intérêt
Le code est plus compact lorsque plusieurs exceptions conduisent exactement à la même
réaction.

Attention
Il ne faut pas regrouper des exceptions qui demandent des traitements différents. La lisibilité
reste prioritaire. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 103 / 138
 Mauvais usage du multi-catch

1 try {
2 chargerFichier() ;
3 convertirDonnees() ;
4 } catch (IOException | NumberFormatException e) {
5 [Link]("Erreur de traitement") ;
6 }

Problème
Une erreur de fichier et une erreur de format n’ont pas toujours le même sens. Dans une
application réelle, on peut vouloir proposer de choisir un autre fichier dans un cas, et signaler
une ligne invalide dans l’autre.

Bonne question
Avant de fusionner plusieurs exceptions, il faut se demander : “Est-ce que la réaction attendue
est vraiment la même ?”
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 104 / 138
 try-with-resources avec variable déjà créée

Dans les versions modernes de Java, une ressource déjà déclarée peut être utilisée dans un
try-with-resources si elle est finale ou effectivement finale.
1 BufferedReader br = new BufferedReader(new FileReader("[Link]")) ;
2
3 try (br) {
4 String ligne = [Link]() ;
5 [Link](ligne) ;
6 } catch (IOException e) {
7 [Link]("Erreur de lecture : " + [Link]()) ;
8 }

Notion de variable effectivement finale

Une variable est effectivement finale si sa valeur n’est pas modifiée après son initialisation.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 105 / 138
Exceptions supprimées : suppressed exceptions

Avec try-with-resources, une exception peut apparaître dans le bloc principal, puis une
autre pendant la fermeture de la ressource.
Dans ce cas :
l’exception principale est conservée ;
l’exception apparue pendant la fermeture est attachée comme exception supprimée ;
elle peut être retrouvée avec getSuppressed().

Pourquoi c’est important ?

Cela évite de perdre l’information initiale tout en gardant les erreurs secondaires utiles au
diagnostic.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 106 / 138
 Afficher les exceptions supprimées

1 try (BufferedReader br = new BufferedReader(new FileReader("[Link]"))) {

2 String ligne = [Link]() ;
3 [Link](ligne) ;
4 } catch (IOException e) {
5 [Link]("Erreur principale : " + [Link]()) ;
6
7 for (Throwable s : [Link]()) {
8 [Link]("Erreur supprimee : " + [Link]()) ;
9 }
10 }

Usage réel
Dans une application professionnelle, ces informations sont généralement envoyées dans les
logs plutôt qu’affichées directement à l’utilisateur.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 107 / 138
Messages d’erreur : utilisateur vs développeur

Une erreur doit souvent produire deux niveaux de message.

Public Type de message
Utilisateur Message simple, rassurant et compréhen-
sible.
Développeur / adminis- Message technique, type d’exception, cause,
trateur stack trace, contexte.

Exemple
Utilisateur : “Impossible d’importer le fichier. Vérifiez son format.”
Log : NumberFormatException ligne 42, colonne montant, valeur=’abc’.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 108 / 138
Exception et sécurité

Il faut éviter d’exposer les détails techniques à l’utilisateur final.

À ne pas afficher publiquement :
chemins complets de fichiers ;
requêtes SQL ;
noms internes de classes ;
stack trace complète ;
informations de connexion ;
détails sur la structure de la base de données.

Risque
Un message trop technique peut aider un attaquant ou inquiéter inutilement l’utilisateur.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 109 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 110 / 138
Pourquoi raisonner par couches ?

Dans une application réelle, le code est souvent organisé en plusieurs couches.

Interface utilisateur : console, Swing, web, mobile ;

Service métier : règles de gestion ;
Repository / DAO : accès aux données ;
Infrastructure : fichiers, réseau, base de données, API externes.

Idée centrale
Toutes les couches ne doivent pas gérer les exceptions de la même façon.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 111 / 138
Schéma de propagation dans une application
Interface utilisateur exception
message clair remontée

Service métier
règles et exceptions métier

Repository / DAO
conversion des erreurs techniques

Fichier / Base / API

erreurs techniques
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Lecture Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 112 / 138
Responsabilité de chaque couche

Couche Responsabilité face aux exceptions

Interface Afficher un message compréhensible, ne pas mon-
trer la stack trace.
Service Appliquer les règles métier, lever des exceptions
métier.
Repository / DAO Capturer les exceptions techniques et conserver la
cause.
Infrastructure Peut produire IOException, SQLException, er-
reurs réseau, etc.

Erreur fréquente
Mettre toute la gestion d’erreurs dans main() ou dans l’interface rend l’application difficile à
maintenir.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 113 / 138
 Transformer une exception technique

1 public class ProduitRepositoryException extends Exception {

2 public ProduitRepositoryException(String message, Throwable cause) {
3 super(message, cause) ;
4 }
5 }
6
7 public Produit trouverParCode(String code) throws ProduitRepositoryException {
8 try {
9 // Requete SQL ou lecture de fichier
10 return null ;
11 } catch (Exception e) {
12 throw new ProduitRepositoryException(
13 "Impossible de charger le produit : " + code, e) ;
14 }
15 }

Point clé
La cause initiale e est conservée. Le diagnostic reste possible.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 114 / 138
Stratégie professionnelle de traitement
Une stratégie simple peut être résumée ainsi :

1 Valider tôt les paramètres.

2 Lever une exception claire quand une règle est violée.
3 Capturer seulement si la couche sait vraiment quoi faire.
4 Transformer les exceptions techniques aux frontières des couches.
5 Journaliser les détails techniques.
6 Afficher un message simple à l’utilisateur.
7 Tester les cas d’erreur importants.

Phrase à retenir
On ne capture pas une exception pour la faire disparaître ; on la capture pour prendre une
décision utile.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 115 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 116 / 138
Pourquoi tester les exceptions ?

Les étudiants testent souvent seulement les cas où tout fonctionne.

Pourtant, dans un logiciel robuste, il faut aussi vérifier :
qu’un paramètre invalide est refusé ;
qu’une règle métier est bien appliquée ;
qu’une exception attendue est bien levée ;
que le message d’erreur est suffisamment clair ;
qu’une ressource est correctement fermée ;
qu’une erreur technique ne casse pas toute l’application.

Objectif pédagogique
Faire comprendre que les tests d’échec sont aussi importants que les tests de réussite.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 117 / 138
 Exemple de test avec JUnit

1 import static [Link].* ;

2 import [Link] ;
3
4 class ProduitTest {
5
6 @Test
7 void prixNegatifDoitLeverException() {
8 assertThrows([Link], () -> {
9 new Produit("Riz", -1000, 5) ;
10 }) ;
11 }
12 }

Lecture
Le test réussit si le constructeur de Produit lève bien une IllegalArgumentException.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 118 / 138
 Vérifier le message d’une exception

1 @Test
2 void quantiteDemandeeSuperieureAuStock() {
3 Produit p = new Produit("Riz", 18000, 3) ;
4
5 StockInsuffisantException ex = assertThrows(
6 [Link],
7 () -> [Link](5)
8 );
9
10 assertTrue([Link]().contains("Stock insuffisant")) ;
11 }

Intérêt
On vérifie non seulement le type de l’exception, mais aussi la qualité du message produit.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 119 / 138
Cas limites à tester

Pour chaque méthode importante, on peut identifier plusieurs familles de tests.

Famille de test Exemples
Cas normal Données valides, traitement attendu.
Borne minimale Note = 0, quantité = 1, solde = montant
exact.
Borne maximale Note = 20, capacité atteinte.
Valeur invalide Note = -1, prix négatif, nom vide.
Ressource absente Fichier introuvable, base inaccessible.

Méthode
Une exception attendue doit apparaître dans les tests, pas seulement pendant les
démonstrations en classe.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 120 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 121 / 138
Contexte de l’étude de cas

On souhaite importer un fichier CSV contenant des notes d’étudiants.

Format attendu :

matricule;nom;note

Exemple :

ETU001;Awa Diop;15.5

Problèmes possibles
Le fichier peut être absent, une ligne peut être mal formée, une note peut être non numérique
ou hors intervalle.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 122 / 138
Types d’erreurs dans l’import CSV

Erreur Traitement possible

Fichier absent Arrêter l’import et informer l’utilisateur.
Ligne mal formée Signaler le numéro de ligne et continuer ou
arrêter selon le besoin.
Note non numérique Signaler une erreur de format.
Note hors intervalle Lever une exception métier
NoteInvalideException.
Nom vide Refuser la ligne.

Discussion
La bonne décision dépend du cahier des charges : import strict ou import tolérant.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 123 / 138
 Exception personnalisée : NoteInvalideException

1 public class NoteInvalideException extends Exception {

2 public NoteInvalideException(String message) {
3 super(message) ;
4 }
5 }

Rôle
Cette exception représente une donnée métier invalide : une note doit être comprise entre 0 et
20.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 124 / 138
 Méthode de validation d’une note

1 public static double validerNote(String valeur)

2 throws NoteInvalideException {
3
4 double note ;
5 try {
6 note = [Link](valeur) ;
7 } catch (NumberFormatException e) {
8 throw new NoteInvalideException(
9 "La note n’est pas numerique : " + valeur) ;
10 }
11
12 if (note < 0 || note > 20) {
13 throw new NoteInvalideException(
14 "La note doit etre comprise entre 0 et 20 : " + note) ;
15 }
16
17 return note ;
18 }

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 125 / 138
 Import strict : arrêt à la première erreur
1 public static void importerNotes(String chemin)
2 throws IOException, NoteInvalideException {
3
4 try (BufferedReader br = new BufferedReader(new FileReader(chemin))) {
5 String ligne ;
6 int numero = 0;
7
8 while ((ligne = [Link]()) != null) {
9 numero++;
10 String[] champs = [Link](" ;") ;
11
12 if ([Link] != 3) {
13 throw new NoteInvalideException(
14 "Ligne " + numero + " invalide : " + ligne) ;
15 }
16
17 double note = validerNote(champs[2]) ;
18 [Link](champs[1] + " : " + note) ;
19 }
20 }
21 } . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 126 / 138
Import strict ou import tolérant ?

Import strict Import tolérant

On arrête tout dès qu’une ligne est invalide. On ignore ou stocke les lignes invalides, puis
Adapté si les données doivent être on continue l’import.
parfaitement cohérentes avant d’être Adapté si l’objectif est de récupérer un
acceptées. maximum de données valides.

Question de conception
La gestion des exceptions dépend souvent des règles métier, pas seulement de Java.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 127 / 138
Activité en classe : concevoir une stratégie d’import

Par groupe de deux ou trois, les étudiants doivent proposer une stratégie pour importer un
fichier de notes.
Questions à traiter :
1 Quelles erreurs doivent arrêter l’import ?
2 Quelles erreurs peuvent être simplement signalées ?
3 Faut-il créer une ou plusieurs exceptions personnalisées ?
4 Quel message afficher à l’utilisateur ?
5 Quelles informations faut-il mettre dans les logs ?
6 Quels tests unitaires faut-il écrire ?

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 128 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 129 / 138
Décider : test simple ou exception ?
Situation Approche recommandée
Cas très prévisible dans le flux Utiliser un if.
normal
Violation d’une règle de mé- Lever IllegalArgumentException.
thode
Violation d’une règle métier Lever une exception métier.
Fichier ou base indisponible Capturer, journaliser ou propager se-
lon la couche.
Bug probable du programme Corriger le bug, ne pas le masquer.

Exemple
Tester si une liste est vide est souvent préférable à capturer une
IndexOutOfBoundsException.
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 130 / 138
Checklist avant de terminer un code avec exceptions

Avant de considérer le code terminé, vérifier les points suivants :

1 Les exceptions capturées sont-elles spécifiques ?
2 Les blocs catch font-ils quelque chose d’utile ?
3 Les ressources sont-elles fermées automatiquement ?
4 Les causes initiales sont-elles conservées ?
5 Le message utilisateur est-il clair ?
6 Le message technique est-il disponible dans les logs ?
7 Les exceptions métier ont-elles des noms explicites ?
8 Les cas d’erreur sont-ils testés ?

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 131 / 138
Erreurs fréquentes à éviter

capturer Exception partout ;

écrire un catch vide ;
afficher directement [Link]() à l’utilisateur ;
perdre la cause initiale en créant une nouvelle exception ;
utiliser les exceptions pour remplacer de simples tests ;
mélanger les erreurs métier et techniques ;
ignorer les ressources à fermer ;
écrire des messages vagues comme "Erreur".

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 132 / 138
Synthèse intermédiaire : stratégie complète

Détecter Classer Décider

Tester Journaliser Traiter / propager

Message final de la méthode

Une exception doit être comprise, classée, traitée au bon niveau, journalisée si nécessaire et
testée.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 133 / 138
Plan de la section
1 Pourquoi gérer les exceptions ?
2 Comprendre la notion d’exception
3 Hiérarchie des exceptions en Java
4 try, catch et finally
5 throw, throws et propagation
6 Exceptions vérifiées et non vérifiées
7 try-with-resources et ressources externes
8 Exceptions personnalisées
9 Étude de cas 1 : compte bancaire
10 Étude de cas 2 : inscription d’étudiants
11 Encapsulation et journalisation
12 Bonnes et mauvaises pratiques
13 Exercices guidés
14 Compléments Java moderne
15 Gestion des exceptions dans une architecture en couches
16 Tester les exceptions .
.
.
.
.
. . . . .
. . . .
. . . .
. . . .
. . . .
. . . . .
.
.
.
.
.
.
.
.
.

17 Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 134 / 138
Quiz de compréhension

1 Qu’est-ce qu’une exception en Java ?

2 Quelle est la différence entre Error et Exception ?
3 Quelle est la différence entre exception vérifiée et non vérifiée ?
4 À quoi sert le bloc finally ?
5 Quelle est la différence entre throw et throws ?
6 Pourquoi l’ordre des blocs catch est-il important ?
7 Pourquoi faut-il éviter les blocs catch vides ?

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 135 / 138
Réponses attendues

1 Une exception est un objet représentant une situation anormale à l’exécution.

2 Error signale souvent un problème grave de JVM ; Exception représente une erreur
applicative.
3 Une checked exception est imposée par le compilateur ; une unchecked exception ne l’est
pas.
4 finally sert à exécuter du code de nettoyage.
5 throw lance une exception ; throws déclare qu’une méthode peut en propager une.
6 Il faut aller du plus spécifique vers le plus général.
7 Ils cachent les erreurs et rendent le diagnostic difficile.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 136 / 138
Synthèse du chapitre

Les exceptions sont indispensables pour construire des programmes robustes.

Elles permettent de séparer le code métier du code de gestion d’erreurs.
Java distingue Error, exceptions vérifiées et exceptions non vérifiées.
try/catch/finally permet de capturer et traiter les erreurs.
throw sert à lancer une exception ; throws sert à la déclarer.
try-with-resources simplifie la gestion des ressources.
Les exceptions personnalisées rendent les règles métier plus expressives.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 137 / 138
Message final

À retenir
Bien gérer les exceptions ne signifie pas capturer toutes les erreurs partout. Cela signifie savoir
où détecter l’erreur, où la traiter, où la propager, comment informer l’utilisateur et comment
aider le développeur à diagnostiquer le problème.

Merci pour votre attention.

. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
Dr. LO (UADB) Java avancé : Gestion robuste des exceptions 18 mai 2026 138 / 138