Introduction : qu’est-ce qu’une exception ?

De nombreux langages de programmation de haut niveau possedent un mecanisme permettant de gerer les erreurs qui peuvent intervenir lors de l’exécution d’un programme. Le mecanisme de gestion d’erreur le plus repandu est celui des exceptions. Nous avons deja abordé le concept d’exception dans le cours sur les fonctions : lorsqu’une fonction n’est pas definie pour certaines valeur de ses arguments on l`eve une exception en utilisant le mot clef throw. Par exemple, la fonction factorielle n’est pas définie pour les nombres negatifs.

1 c l a s s F a c t o r i e l l e {
2 s t a t i c i n t f a c t o r i e l l e ( i n t n ) {
3 i n t r e s = 1 ;
4 i f ( n <0) {
5 throw new P a s D e f i n i ( ) ;
6 }
7 f o r ( i n t i = 1 ; i <= n ; i + + ) {
8 r e s = r e s ∗ i ;
9 }
10 r e t u r n r e s ;
11 }
12 }
13
14 c l a s s P a s D e f i n i e x t e n d s E r r o r {}

Définir des exceptions

Afin de definir une nouvelle sorte d’exception, on crée une nouvelle classe en utilisant une declaration de la forme suivante :
class Nouvelle Exception extends Exception Deja Definie {}
On peut remarquer ici la presence du mot clé extends, dont nous verrons la signification dans un chapitre ult´erieur qui traitera de l’heritage entre classes. Dans cette construction, Nouvelle Exception est le nom de la classe d’exception que l’on desire definir en “etendant” Exception Deja Definie qui est une classe d’exception deja definie. Sachant que Error est predefinie en Java, la declaration suivante definit la nouvelle classe d’exception Pas Defini:
class PasDefini extends Error {}
Il existe de nombreuses classes d’exceptions predefinies en Java, que l’on peut classer en trois categories :
– Celles definies par extension de la classe Error : elles représentent des erreurs critiques qui ne sont pas censées etre gerées en temps normal. Par exemple, une exception de type OutOfMemoryError est levée lorsqu’il n’y a plus de m´emoire disponible dans le systeme.
Comme elles correspondent `a des erreurs critiques elles ne sont pas normalement censées etre recuperées et nous verrons plus tard que cela permet certaines simplifications dans l’´erciture de m´ethodes pouvant lever cette exception.

Lever une exception

Lorsque l’on veut lever une exception, on utilise le mot cl´e throw suivi de l’exception `a lever, qu’il faut avoir crée auparavant avec la construction new NomException() Ainsi lancer une exception de la classe PasDefini s’écrit :
throw new PasDefini();
Lorsqu’une exception est levée, l’execution normale du programme s’arrete et on saute toutes les instructions jusqu’`a ce que l’exception soit rattrapée ou jusqu’`a ce que l’on sorte du programme. Par exemple, si on considere le code suivant :

Listing 10.2 – (lien vers le code brut)
1 p u b l i c c l a s s A r r e t {
2 p u b l i c s t a t i c v o i d m a in ( S t r i n g [ ] a r g s ) {
3 i n t x = T e r m i n a l . l i r e I n t ( ) ;
4 T e r m i n a l . e c r i r e S t r i n g l n ( ” Coucou 1 ” ) ; / / 1
5 i f ( x >0){
6 throw new S t o p ( ) ;
7 }
8 T e r m i n a l . e c r i r e S t r i n g l n ( ” Coucou 2 ” ) ; / / 2
9 T e r m i n a l . e c r i r e S t r i n g l n ( ” Coucou 3 ” ) ; / / 3
10 T e r m i n a l . e c r i r e S t r i n g l n ( ” Coucou 4 ” ) ; / / 4
11 }
12 }
13 c l a s s S t o p e x t e n d s R u n t i m e E x c e p t i o n {}

Rattraper une exception

10.4.1 La construction try catch
Le rattrapage d’une exception en Java se fait en utilisant la construction :

Listing 10.3 – (pas de lien)
1 t r y {
2 . . . / / 1
3 } c a t c h ( U n e E x c e p t i o n e ) {
4 . . . / / 2
5 }
6 . . / / 3

Le code 1 est normalement exécuté. Si une exception est levée lors de cette exécution, les instructions restantes dans le code 1 sont abandonnées. Si la classe de l’exception levée dans le bloc 1 est Une Exception alors le code 2 est executé (car l’exception est recuperée). Dans le code 2, on peut faire reference a l’exception en utilisant le nom donné a celle-ci lorsque l’on nomme sa classe. Ici le nom est e. Dans le cas ou la classe de l’exception n’est pas Une Exception, le code 2 et le code 3 sont sautés…

10.4.2 Rattraper plusieurs exceptions
Il est possible de rattraper plusieurs types d’exceptions en enchaînant les constructions catch :

Listing 10.6 – (lien vers le code brut)
1 p u b l i c c l a s s A r r e t 3 {
2 p u b l i c s t a t i c v o i d P ( ) {
3 i n t x = T e r m i n a l . l i r e I n t ( ) ;
4
5 i f ( x >0){
6 throw new S t o p 2 ( ) ;
7 }
8 }
9 p u b l i c s t a t i c v o i d m a in ( S t r i n g [ ] a r g s ) {
10 T e r m i n a l . e c r i r e S t r i n g l n ( ” Coucou 1 ” ) ; / / 1
11 t r y {
12 P ( ) ;
13 T e r m i n a l . e c r i r e S t r i n g l n ( ” Coucou 2 ” ) ; / / 2
14 } c a t c h ( S t o p e ) {
15 T e r m i n a l . e c r i r e S t r i n g l n ( ” Coucou 3 ” ) ; / / 3
16 }
17 } c a t c h ( S t o p 2 e ) {
18 T e r m i n a l . e c r i r e S t r i n g l n ( ” Coucou 3 b i s ” ) ; / / 3 b i s
19 }
20 T e r m i n a l . e c r i r e S t r i n g l n ( ” Coucou 4 ” ) ; / / 4
21 }
22 }
23 c l a s s S t o p e x t e n d s R u n t i m e E x c e p t i o n {}
24 c l a s s S t o p 2 e x t e n d s R u n t i m e E x c e p t i o n {}*

Si le lien ne fonctionne pas correctement, veuillez nous contacter (mentionner le lien dans votre message)
Cous Java les exceptions (129 Ko) (Cours PDF)