SOMMAIRE

SOMMAIRE.........................................................................................................................................1
LISTE DES FIGURES..............................................................................................................................2
INTRODUCTION..................................................................................................................................3

1
 LISTE DES FIGURES

Figure 1 IMPLE MENTATION DE LA CLASSE ATTRAPE..............................................................4

Figure 2 CLASSE EXCEPTION............................................................................................................5
Figure 3 CLASSE LANCE....................................................................................................................6
Figure 4 RESULTATS DE L’EXECUTION DE LA CLASSE LANCE...............................................6

2
 INTRODUCTION

Bien souvent, un programme doit traiter des situations exceptionnelles qui n'ont pas un

rapport direct avec sa tâche principale. Ceci oblige le programmeur à réaliser de nombreux

tests avant d'écrire les instructions utiles du programme. Cette situation a deux inconvénients

majeurs : le programmeur peut omettre de tester une condition, le code devient vite illisible,

car la partie utile est masquée par les tests. Java remédie à cela en introduisant un Mécanisme

de gestion des exceptions qui est l'objet de cet article. Grâce à ce mécanisme, on peut

améliorer grandement la lisibilité du code en découplant le code utile de celui qui traite des

situations exceptionnelles, et on peut aussi déléguer au langage la tâche d'énumération des

tests à effectuer

3
 I. GENERALITES

Une exception correspond à un évènement inattendu, à un type d’erreur ; c’est un objet, une
instance d'une classe d’exceptions. Une exception peut provoquer la sortie d'une méthode et
contient les informations sur cette erreur. En Java, les exceptions sont des objets ayant 3
caractéristiques : un type d’exception, une chaîne de caractères et un « instantané » de la pile
d’exécution au moment de la création. RunTimeException, Error sont des exceptions et des
erreurs prédéfinies et/ou gérées par Java. Le constructeur d’une classe peut prévoir une
classe exception qui va être lancée au cas où on aurait une situation indésirée, cette classe
doit étendre la classe java.lang.Exception. Quand une exception est « lancée », elle se «
propage » mais on peut l’« attraper ». Ceci signifie que toute les instructions qui suivent le
lancement de l’exception sont ignorées , en remontant éventuellement d’une méthode à la
méthode appelante, jusqu’à ce qu’un mécanisme attrape l’exception ou jusqu’à ce que cette
dernière. La classe java.lang.Throwable est étendue par les classe java.lang.Exception et
java.lang.Error. Les instances de sous-classes de la classe java.lang.Exception servent pour
les évènements inattendus, qui seront souvent traités de sorte qu’ils ne provoquent pas l’arrêt
du programme; les instances de sous-classe de la classe java.lang.Error servent pour des
erreurs graves, qui devront généralement conduire à l’arrêt du programme.

Figure 1 IMPLE  MENTATION DE LA CLASSE ATTRAPE

Commentaires :
P

4
 -entier = Integer.parseInt(liste[i]); : si la chaine de caractères liste[i] ne correspond

pas à un entier, la méthode parseInt lance une

exception,instancede T

NumberFormatException. Ici donc, si liste[i] ne décrit pas un entier, la valuation de la

I variable entier et les deux instructions qui quivent :

C - somme = +=entier;
- nbNotes ++; Ne sont pas effectuées, et on passe à l’instrcution println Intérieure au bloc
catch, puis on remonte dans la boucle for qui reprend son déroulement .

Si l’on veut pouvoir traiter avec une exception un évènement d’un type non prévu par
l’API, il faut étendre la classe Exception ou une de ses sous-classes : la classe étendue ne
contiendra en général pas d’autre champ qu’un (ou plusieurs) constructeur(s) et
éventuellement une redéfinition de la méthode toString. Lors du lancement de l’exception,
(qui se fait à l’aide du mot clé throw), on crée une instance de la classe définie

Figure 2 CLASSE EXCEPTION

Nous allons partir d’un exemple du slide sur le calcul de la moyenne des notes
entières envoyées en arguments par ligne de commande

5
Figure 3 CLASSE LANCE

Figure 4 RESULTATS DE L’EXECUTION DE LA CLASSE LANCE

Une exception s’est produite et les instructions de la classe exception ont été exécutées .

II. TRAITEMENT DES EXCEPTIONS 

Il y a deux manières de traiter une exception reçue :

6
  Propagation : L'exception est renvoyée à la méthode ayant invoquée initialesAuteur

 Interception : L'exception est traitée dans la méthode initialesAuteur et "disparaît

III. EMISSION ET CREATION DES EXCEPTIONS

On doit prévoir tous les cas d'erreurs des méthodes que vous écrivez émettant les exceptions
appropriées:
⚫ Créer un objet d'une classe d'exception T
⚫ Émettre l'exception

IV. BLOCS FINALY

Un bloc finaly est toujours associé à un bloc try . il est utilisé pour effectuer des
nettoyages (fermer des fichiers, libérer des ressources…). Lorsqu’un bloc finally figure,
quelle que soit la façon dont on est sortie du bloc try (par une instruction break, ou return,
par une propagation d’exception ou normalement), les instruction contenues dans le bloc
fanally sont exécutés.

V. QUELUES EXCEPTIONS PREDEFINIES

 Division par zéro pour les entiers : ArithmeticException
 Référence nulle : NullPointerException
 Tentative de forçage de type illégale : ClassCastException
 Tentative de création d'un tableau de taille négative : NegativeArraySizeException
 Dépassement de limite d'un tableau : ArrayIndexOutOfBoundsException

7
 CONCLUSION

En somme, nous pouvons dire que l’utilisation des exceptions est d’une importance
capitale dans la programmation d’une application afin d’éviter les bugs et les erreurs et
permettre une utilisation efficace de l’application.

8
 BIBLIOGRAPHIE
 Cours non publié de Programmation Orientée Objet : Application JAVA de Dr
BATCHAKUI BERNABE