La gestion des erreurs et des exceptions
- Rubrique
- Développement
- Niveau
- Intermédiaire
- Lecture
- 11 min (essentiel)
12 min (complet) - Révision
- 4 novembre 2026
En bref
- Une exception est un signal d’erreur transmis automatiquement de fonction en fonction jusqu’à ce que du code l’attrape ; sans attrapeur, le programme s’arrête avec un message.
- Le bloc try entoure ce qui peut échouer, le bloc catch (ou except) traite l’échec, le bloc finally s’exécute toujours, pour nettoyer.
- Les codes d’erreur (-1, adresse nulle) obligent à tester à chaque appel et se confondent avec des valeurs normales ; les exceptions évitent cela, mais peuvent cacher des chemins d’exécution.
- Mauvaise habitude à bannir : le bloc qui avale l’erreur sans rien faire ; une erreur ignorée devient un bogue plus tard, et plus difficile à trouver.
- Un message d’erreur doit aider celui qui répare, sans révéler à un attaquant des informations internes.
Prérequis conseillés : Les fonctions
1Pourquoi anticiper les erreurs
Tout programme comporte des erreurs, même s’il semble fonctionner à merveille. Certaines sont des fautes d’écriture, que le compilateur ou l’éditeur signale (voir la compilation). D’autres sont des situations que le programmeur ne contrôle pas : le disque est plein, le fichier a été supprimé, le serveur distant ne répond plus, l’utilisateur tape « abc » quand on attend un nombre. Ce ne sont pas des bogues : ce sont des événements normaux, qu’il faut prévoir.
1.1La méthode ancienne : les codes d’erreur
La solution historique consiste à faire retourner par une fonction une valeur spéciale pour signaler l’échec, souvent -1 ou une adresse nulle (NULL). C’est la méthode du langage C, où la variable errno précise la cause. Cette méthode a trois défauts, qui restent exacts :
- elle alourdit l’écriture : après chaque appel, il faut tester le code ;
- elle brouille la lecture : les tests s’imbriquent (
if ... else) jusqu’à noyer le fil du programme ; - la valeur d’erreur peut être confondue avec une valeur normale : -1 est parfois un résultat légitime.
À cela s’ajoute un défaut que l’on souligne rarement : on peut oublier de tester, et le programme continue alors avec une valeur fausse. Beaucoup de failles de sécurité viennent de là.
1.2La méthode moderne : les exceptions
Une exception est un objet qui décrit un événement anormal. Au lieu de renvoyer un code, la fonction qui rencontre le problème lève l’exception (verbes throw ou raise). Le déroulement normal s’arrête aussitôt, et l’exception remonte la pile d’appels, c’est-à-dire la liste des fonctions en cours (celle qui a appelé celle qui a appelé…), jusqu’à trouver un bloc qui l’attrape. La figure 1 en montre le trajet.
Les exceptions ont un avantage : la transmission est implicite. Les fonctions intermédiaires n’ont rien à écrire pour laisser passer l’erreur, ce qui rend le code plus lisible.
2Les exceptions en Java
2.1try et catch
Voici le principe, tel qu’on le montrait autrefois et tel qu’on l’écrit aujourd’hui :
try {
int resultat = 10 / diviseur; // peut échouer
System.out.println(resultat);
} catch (ArithmeticException e) {
System.out.println("Division impossible : " + e.getMessage());
}
// ici, le programme continue normalement
Le bloc try (« essayer ») contient les instructions qui risquent d’échouer. Si l’une d’elles lève une exception, l’exécution saute immédiatement au bloc catch (« attraper ») dont le type convient, et les instructions restantes du try sont ignorées. Aucune instruction ne doit se trouver entre le try et le catch. Quand diviseur vaut 0, la division entière lève une ArithmeticException ; avec un nombre décimal, elle donnerait simplement « infini » sans erreur.
Le vocabulaire est parfois un peu flou : le bloc catch ne « lève » pas l’exception, il l’attrape. On lève (throw) une exception, on l’attrape (catch) ou on la laisse passer.
2.2Où cherche-t-on le catch ?
On écrit parfois que l’interpréteur cherche un catch « vers le bas ». En réalité la recherche se fait vers le haut de la pile d’appels : d’abord dans le bloc try courant, puis dans la fonction qui a appelé la fonction courante, et ainsi de suite. Si personne n’attrape l’exception, le gestionnaire par défaut de la machine virtuelle affiche le nom de l’exception et la trace de pile (la liste des fonctions traversées, avec les numéros de ligne), puis termine le programme ou le fil d’exécution en cause.
On montre aussi comment relancer une exception depuis un catch, parfois avec une syntaxe inexacte (throw (TypeException)e;). La forme correcte est throw e; pour relancer telle quelle, ou throw new MonException("contexte", e); pour la chaîner : on crée une nouvelle exception qui garde l’ancienne comme cause. C’est la bonne façon d’ajouter du contexte sans perdre l’origine.
2.3Plusieurs catch, et finally
Un try peut avoir plusieurs catch, du plus précis au plus général : le premier qui convient prend l’exception. Depuis Java 7 (2011), un même catch peut en couvrir plusieurs (catch (IOException | SQLException e)). Le bloc finally s’exécute dans tous les cas : après un try réussi, après un catch, et même après un return. Il sert à nettoyer, c’est-à-dire fermer un fichier, rendre une connexion, libérer un verrou. La figure 2 en montre les chemins.
Java 7 a aussi apporté le try avec ressources, qui ferme automatiquement ce qui a été ouvert, et dispense du finally dans le cas courant :
try (BufferedReader lecteur = Files.newBufferedReader(chemin)) {
String ligne = lecteur.readLine();
} // lecteur est fermé ici, quoi qu'il arrive
2.4Exceptions contrôlées ou non
Java distingue deux familles. Les exceptions contrôlées (checked), comme IOException, doivent être soit attrapées, soit déclarées dans la signature de la méthode par le mot throws : le compilateur l’exige. Les exceptions non contrôlées (sous-classes de RuntimeException), comme NullPointerException (utilisation d’une référence vide), ArrayIndexOutOfBoundsException (case hors du tableau) ou NumberFormatException (texte mal formé), sont des erreurs de programmation qu’on ne déclare pas. Enfin les Error (par exemple OutOfMemoryError, plus de mémoire) signalent un problème grave de la machine et ne s’attrapent presque jamais. L’idée était de forcer à penser aux erreurs ; en pratique, beaucoup d’équipes trouvent le contrôle pesant, et d’autres langages (C#, Kotlin, Python) ne l’ont pas repris.
2.5Connaître le type et la cause
Reste à connaître le type de l’exception. Les outils sont simples : la variable e possède getMessage() (la phrase décrivant l’erreur), getCause() (l’exception d’origine), getStackTrace() (la pile) et on peut tester son type avec instanceof. En production, on envoie ces informations dans un journal (fichier de traces) plutôt que sur l’écran de l’utilisateur.
2.6Lever et créer ses propres exceptions
On ne fait pas qu’attraper : une fonction qui détecte une situation invalide la signale elle-même. Un virement dont le montant est négatif n’a pas de sens, et la fonction qui le reçoit doit refuser :
if (montant <= 0) {
throw new IllegalArgumentException("montant invalide : " + montant);
}
Quand les types fournis ne suffisent pas, on crée les siens, en héritant de Exception (contrôlée) ou de RuntimeException (non contrôlée) :
class SoldeInsuffisantException extends Exception {
SoldeInsuffisantException(String message) { super(message); }
}
Une exception bien nommée raconte ce qui s’est passé et permet à l’appelant de réagir différemment selon le cas : redemander un montant pour une exception de solde, abandonner pour une exception de base de données.
Pour s’exercer
Exercice 1 : Dans quel ordre ça s’affiche ?
Que fait ce code Java quand diviseur vaut 0 ? Et quand il vaut 2 ? Que renvoie la méthode dans chaque cas ?
static int f(int diviseur) {
try {
System.out.println("A");
int x = 10 / diviseur;
System.out.println("B");
return 1;
} catch (ArithmeticException e) {
System.out.println("C");
return 2;
} finally {
System.out.println("D");
}
}
Voir la réponse
Avec 0 : le programme affiche A, puis la division échoue et lève une ArithmeticException ; il affiche C, puis D (le bloc finally s’exécute toujours, même après un return), et la méthode renvoie 2. Avec 2 : il affiche A, B, D et la méthode renvoie 1.
Exercice 2 : Réparer un catch vide
Un collègue a écrit : try { lireConfiguration(); } catch (Exception e) { }. Donnez deux raisons pour lesquelles c’est dangereux, puis proposez une version meilleure.
Voir la réponse
Première raison : l’erreur est avalée en silence, donc personne n’apprend que la configuration n’a pas été lue, et le programme continue avec des valeurs manquantes. Seconde raison : Exception attrape aussi des erreurs sans rapport (un bogue du code, par exemple), qui se retrouvent cachées. Une version meilleure : try { lireConfiguration(); } catch (IOException e) { journal.erreur("Configuration illisible", e); utiliserValeursParDefaut(); }. On attrape l’erreur précise attendue, on la note dans un journal et on décide clairement de la suite (ou on la relance).
Exercice 3 : Exception ou code d’erreur ?
Pour chaque cas, dites si l’on utilise plutôt une exception ou un résultat renvoyé, et pourquoi : (a) le fichier demandé n’existe pas ; (b) un utilisateur tape « douze » dans une zone de nombre ; (c) on cherche un client dans une liste et on ne le trouve pas.
Voir la réponse
(a) Une exception : un fichier absent est une situation anormale, et la fonction ne peut pas fournir de résultat valable ; l’exception force l’appelant à réagir. (b) Plutôt un résultat renvoyé : une erreur de saisie est fréquente et prévisible, on la vérifie et on affiche un message à l’utilisateur sans interrompre le programme. (c) Un résultat renvoyé (valeur vide, null ou -1) : ne pas trouver un client est un cas normal de la recherche, pas une panne.