Formation JAVA les exceptions, tutoriel & guide de travaux pratiques en pdf.

Definir des exceptions

Afin de definir une nouvelle sorte d’exception, on cree une nouvelle classe en utilisant une declaration de la forme suivante :
class NouvelleException extends ExceptionDejaDefinie {}
On peut remarquer ici la pr´esence du mot cl´e extends, dont nous verrons la signification dans un chapitre ulterieur qui traitera de l’h´eritage entre clas ses. Dans cette construction, NouvelleException est le nom de la classe d’exception que l’on desire definir e n’etendant” ExceptionDejaDefinie qui est une classe d’exception deja definie. Sachant que Error est pr´ed´efinie en Java, la declaration suivante definit la nouvelle classe d’exception PasDefini :
class PasDefini extends Error {}
Il existe de nombreuses classes d’exceptions predefinies en Java, que l’on peut classer en trois cat´egories :
– Celles d´efinies par extension de la classe Error : elles representent des erreurs critiques qui ne sont pas censees etre gérees en temps normal. Par e xemple, une exception de type OutOfMemoryError est levee lorsqu’il n’y a plus de m´emoire disponible dans l e syst`eme. Comme elles correspondent a` des erreurs critiques elles ne sont pas normalement cens´ees etreˆ r´ecup´er´ees et nous verrons plus tard que cela permet cert aines simplifications dans l’´erciture de m´ethodes pouvant lever cette exception.
– Celles d´efinies par extension de la classe Exception : elles repr´esentent les erreurs qui
doivent normalement etreˆ g´er´ees par le programme. Par ex emple, une exception de type IOException est lev´ee en cas d’erreur lors d’une entr´ee sortie.
– Celles d´efinies par extension de la classe RuntimeException : elles repr´esentent des er-reurs pouvant eventuellement´ etreˆ g´er´ees par le progra mme. L’exemple typique de ce genre
d’exception est NullPointerException, qui est lev´ee si l’on tente d’acc´eder au contenu d’un tableau qui a et´ d´eclar´ mais pas encore cr´e´ par un new.
Chaque nouvelle exception entre ainsi dans l’une de ces trois cat´egories. Si on suit rigoureusement ce classement (et que l’on fait fi des simplifications evoqu´ ees plus haut), l’exception PasDefini aurait due etreˆ d´eclar´ee par :
class PasDefini extends Exception {} ou bien par :
class PasDefini extends RuntimeException {}
car elle ne constitue pas une erreur critique.

Lever une exception

Lorsque l’on veut lever une exception, on utilise le mot cle throw suivi de l’exception a` lever, qu’il faut avoir cree auparavant avec la construction new NomException() Ainsi lancer une exception de la classe PasDefini s’´ecrit :
throw new PasDefini();
Lorsqu’une exception est lev´ee, l’ex´ecution normale du p rogramme s’arrete et on saute toutes les instructions jusqu’`a ce que l’exception soit rattrap´ee o u jusqu’`a ce que l’on sorte du programme. Par exemple, si on consid`ere 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 i n ( 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 ( ” Co u c o u 1”); / / 1
5 i f ( x >0){
6 t hr o w 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 ( ” Co u c o u 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 ( ” Co u c o u 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 ( ” Co u c o u 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 {}
l’ex´ecution de la commande java Arret puis la saisie de la valeur 5 (pour la variable x) produira l’affichage suivant :
Coucou 1
Exception in thread « main » Stop
at Arret.main(Arret.java:7)
C’est-a`-dire que les instructions 2, 3 et 4 n’ont pas et´ e x´ecut´ees. Le programme se termine en indi-quant que l’exception Stop lanc´ee dans la m´ethode main a` la ligne 7 du fichier Arret.java n’a pas et´ rattrap´ee.

Rattraper une exception

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´ecut´. Si une exception est levee´ lors de cette ex´ecution, les instruc-tions restantes dans le code 1 sont abandonn´ees. Si la classe de l’exception lev´ee dans le bloc 1 est UneException alors le code 2 est ex´ecut´ (car l’exception est r´ecup´er ee)´. Dans le code 2, on peut faire r´ef´erence a` l’exception en utilisant le nom donn´e 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 UneException, le code 2 et le code 3 sont saut´es. Ainsi, le programme suivant :
Listing 10.4 – (lien vers le code brut)
1 p u b l i c c l a s s A r r e t 2 {
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 t hr o w new S t o p ( ) ;
7 }
8 }
9 p u b l i c s t a t i c v o i d m a i n ( 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 ( ” Co u c o u 1”); / / 1
11
12 t r y {
13 P ();
14 T e r m i n a l . e c r i r e S t r i n g l n ( ” Co u c o u 2” ); / / 2
15 } c a t c h ( S t o p e ) {
16 T e r m i n a l . e c r i r e S t r i n g l n ( ” Co u c o u 3” ); / / 3
17 }
18 T e r m i n a l . e c r i r e S t r i n g l n ( ” Co u c o u 4 ” ) ; / / 4
19 }
20 }
21 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 {}
produit l’affichage suivant lorsqu’il est ex´ecut´ et que l ‘on saisit une valeur positive :
Coucou 1
Coucou 3
Coucou 4
On remarquera que l’instruction 2 n’est pas ex´ecut´ (du fa it de la lev´ee de l’exception dans P. Si on ex´ecute ce mˆeme programme mais en saisissant une vale ur n´egative on obtient :
Coucou 1
Coucou 2
Coucou 4
car l’exception n’est pas lev´ee.
En revanche le programme suivant, dans lequel on l`eve une exception Stop2, qui n’est pas
r´ecup´er´ee.
Listing 10.5 – (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 t hr o w 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 i n ( 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 ( ” Co u c o u 1”); / / 1
11 t r y {
10.4. RATTRAPER UNE EXCEPTION 5
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 ( ” Co u c o u 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 ( ” Co u c o u 3” ); / / 3
16 }
17 T e r m i n a l . e c r i r e S t r i n g l n ( ” Co u c o u 4 ” ) ; / / 4
18 }
19 }
20 c l a s s S t o p e x t e n d s
21 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 {}
R u n t i m e E x c e p t i o n {}
produit l’affichage suivant lorsqu’il est ex´ecut´ et que l ‘on saisit une valeur positive :
Coucou 1
Exception in thread « main » Stop2
at Arret3.P(Arret3.java:7)
at Arret3.main(Arret3.java:15)

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 t hr o w 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 i n ( 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 ( ” Co u c o u 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 ( ” Co u c o u 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 ( ” Co u c o u 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 ( ” Co u c o u 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 ( ” Co u c o u 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 {}