Les Exceptions

http://www.labo-sun.com
[email protected]
Auteur : Stéphane Arnault
Version n° 2.1 – 17 avril 2017
Nombre de pages : 18
Ecole Supérieure d’Informatique de Paris
23. rue Château Landon 75010 – PARIS
www.supinfo.com
Les Exceptions
GESTION D'ERREURS

Les Exceptions - Gestion d'erreurs
2 / 18
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs

Les Exceptions - Gestion d'erreurs
3 / 18
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Table des matières
1. PRESENTATION ............................................................................................................................................. 4
2. TRAITEMENT DES ERREURS ..................................................................................................................... 5
2.1. GESTION D’ERREUR ....................................................................................................................................... 5
2.1.1. Erreur prévue ........................................................................................................................................ 5
2.1.2. Erreur imprévue .................................................................................................................................... 5
2.1.3. Erreurs surveillées / Erreurs non surveillées ........................................................................................ 6
3. LES EXCEPTIONS........................................................................................................................................... 7
3.1. INTRODUCTION ............................................................................................................................................. 7
3.2. DEFINITION ................................................................................................................................................... 7
3.3. LES CLASSES D’EXCEPTIONS ......................................................................................................................... 8
3.3.1. La classe fille Error .............................................................................................................................. 8
3.3.2. La classe fille Exception ........................................................................................................................ 8
3.4. GESTION DES EXCEPTIONS............................................................................................................................. 9
3.4.1. Le bloc try / catch .................................................................................................................................. 9
3.5. REMONTEE DES EXCEPTIONS ....................................................................................................................... 10
3.6. LES EXCEPTIONS CHAINEES ......................................................................................................................... 11
3.6.1. Modifier l’origine d’une exception...................................................................................................... 12
3.6.2. Le mot clé finally ................................................................................................................................. 13
4. LEVER SOI-MEME DES EXCEPTIONS .................................................................................................... 14
5. CREER SES PROPRES EXCEPTIONS ....................................................................................................... 15
6. LES LOGS ....................................................................................................................................................... 16
6.1. LA GESTION DES LOGS ................................................................................................................................. 16
6.1.1. La mise en place de commons-logging ................................................................................................ 16
6.1.2. Les différents warning ......................................................................................................................... 16
6.2. EXEMPLE DE GESTION DE LOG AVEC COMMONS-LOGGING .......................................................................... 16
7. CONCLUSION ................................................................................................................................................ 18

Les Exceptions - Gestion d'erreurs
4 / 18
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
1. Présentation
A l’origine, Java a été conçu dans l’optique de se définir comme un système embarqué. Ces systèmes
embarqués ou programmes, sont intégrés dans des périphériques spécialisés comme les PDA
1
, les
téléphones portables, et autres appareils électroménagers divers. Pour ce type d’utilisation, il parait
indispensable de prendre en compte une gestion efficace des erreurs du logiciel.
En effet, il n’est pas concevable pour beaucoup d’utilisateurs d’avoir un appareil de type téléphone,
micro-onde ou encore grille pain qui devienne hors service suite à un disfonctionnement du logiciel
intégré dans l’appareil.
Il n’est pas possible d’éliminer toute possibilité d’erreur dans nos programmes, mais nous pouvons
tout de même tenter de résoudre les problèmes en ciblant et en analysant les éventuelles erreurs de
l’application qui pourront être prévues de manière rigoureuse et systématique.
1
Personal Digital Assistant

Les Exceptions - Gestion d'erreurs
5 / 18
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
2. Traitement des erreurs
A la suite d’une erreur à l’exécution d’un programme deux manières de gérer cette erreur sont
possibles :
2.1. Gestion d’erreur
2.1.1. Erreur prévue
Si l’erreur a été prévue par le programmeur, ce qui peut être un cas exceptionnel suite à une erreur
engendrée par un utilisateur qui entrerait une valeur trop grande, le programme doit prévoir des lignes
de code spécialement prévues pour traiter ces erreurs particulières.
2.1.2. Erreur imprévue
Selon que l’erreur était prévisible ou non, deux cas de figure possible :
Erreur qui était prévisible
Si l’erreur était prévisible ce cas de figure ne peut avoir lieu en Java car le compilateur doit détecter
toutes les erreurs et donc forcer le programmeur à tenir compte de ses erreurs. L’erreur prévisible
provient du programmeur qui aurait omis de prendre en compte certains paramètres.
Erreur imprévisible
Dans ce cas, l’erreur provient d’une lacune dans le programme et dépend des conditions dans
lesquelles le programme a été exécuté.
L’interpréteur Java (machine virtuelle) produit alors un message d’erreur et l’exécution est stoppée.
Exception qui est levé lors du RunTime, par exemple l’utilisation d’une méthode d’un objet ayant une
référence null:
package com.labo.sun;
public class Exceptions {
public static void main(String[] args) {
String var = null;
var.charAt(0);
}
}
Ce qui donne l’exception suivante :
Exception in thread "main" java.lang.NullPointerException
at com.labo.sun.Exceptions.main(Exceptions.java:7)
Remarque : L’attitude imposée au programmeur consiste à signaler l’erreur et à arrêter le
traitement.