Le document traite de la gestion des exceptions en Java, un mécanisme crucial pour gérer les erreurs lors de l'exécution d'un programme. Il aborde différents types d'exceptions, leur causes et exemples de code illustrant la manière de les gérer, notamment à travers les blocs try-catch. Le texte explique également comment créer des exceptions personnalisées et l'importance du bloc finally.

1. Les exceptions
Axel KAMALAK

2. Les exceptions
La notion d'exception est un mécanisme permettant au
développeur JAVA de traiter de manière efficace et simple le
problème de la gestion des erreurs lors de l'exécution d'un
programme.
Il s'agit d'un signal qui indique qu'un évènement anormal est
survenu dans un programme. La récupération de l'exception
permet au programme de s'exécuter.

3. Les exceptions
Différentes causes sont à l’origine de ce problème :
L’utilisateur

4. Les exceptions
Différentes causes sont à l’origine de ce problème :
L’utilisateur Le développeur

5. Les exceptions
Différentes causes sont à l’origine de ce problème :
L’utilisateur peut entrer des données
non autorisées.
Un chiffre au lieu d’un nombre, …

6. Les exceptions
Différentes causes sont à l’origine de ce problème :
Le développeur peut avoir oublié
de tester une condition

7. Les exceptions
Différentes causes sont à l’origine de ce problème :
Le développeur peut avoir oublié
de tester une condition

8. Les exceptions
Différentes causes sont à l’origine de ce problème :
Si le développeur écrit trop de test,
le code devient vite illisible.

9. Les exceptions
Différentes causes sont à l’origine de ce problème :
Si le développeur écrit trop de test,
le code devient vite illisible.
Pour répondre à ce besoin, le langage JAVA propose la gestion des
évènements.

10. Les exceptions
Soit le programme suivant :
package Exercice;
public class Exercice3 {
public static void main (String [] args)
{
int a = 5 ;
int b= 6 ;
int c =0 ;
int somme = a*b/c;
System.out.println(somme);
}}

11. Les exceptions
Soit le programme suivant :
package Exercice;
public class Exercice3 {
public static void main (String [] args)
{
int a = 5 ;
int b= 6 ;
int c =0 ;
int somme = a*b/c;
System.out.println(somme);
}}

12. Les exceptions
package Exercice;
public class Exercice3 {
public static void main (String [] args)
{
int a = 5 ;
int b= 6 ;
int c =0 ;
int somme = a*b/c;
System.out.println(somme);
}}

13. Les exceptions
package Exercice;
public class Exercice3 {
public static void main (String [] args)
{
int a = 5 ;
int b= 6 ;
int c =0 ; L’utilisateur peut entrer 0
int somme = a*b/c;
System.out.println(somme);
}}

14. Les exceptions
package Exercice;
public class Exercice3 {
public static void main (String [] args)
{
int a = 5 ;
int b= 6 ;
int c =0 ; Génération d’erreur
int somme = a*b/c;
System.out.println(somme);
Exception in thread "main" java.lang.ArithmeticException: / by zero
}} at Exercice.Exercice3.main(Exercice3.java:11)

15. Les exceptions
Nous pourrions résoudre ce problème à l’aide d’un
test if – else.
package Exercice;
public class Exercice3 {
public static void main (String [] args)
{
int a = 5 ; Il faudrait tester que la variable c
int b= 6 ; est différent de 0.
int c =0 ;
int somme = a*b/c;
System.out.println(somme);
}}

16. Les exceptions
Nous pourrions résoudre ce problème à l’aide d’un
test if – else.
package Exercice;
public class Exercice3 {
public static void main (String [] args)
{
int a = 5 ; Il faudrait tester que la variable c
int b= 6 ; est différent de 0.
int c =0 ;
if(c!=0)
{
int somme = a*b/c;
System.out.println(somme);
}
}}

17. Les exceptions
Nous pourrions résoudre ce problème à l’aide d’un
test if – else.
package Exercice;
public class Exercice3 {
public static void main (String [] args)
{
int a = 5 ; Ce qui risque d’ alourdir le code et
int b= 6 ; le code va vite devenir illisible.
int c =0 ;
if(c!=0)
{
int somme = a*b/c;
System.out.println(somme);
}
}}

18. Les exceptions
public class Exercice3 {
public static void main (String [] args)
{
int a = 5 ;
int b= 6 ;
int c = 0 ;
try{
int somme = a*b/c;
System.out.println(somme);
}
catch (ArithmeticException e)
{
System.out.println("Interdit de diviser par 0 !");
}
}
}

19. Les exceptions
public class Exercice3 {
public static void main (String [] args)
{
int a = 5 ;
int b= 6 ;
int c = 0 ;
Cette zone peut générer
try{ une erreur
int somme = a*b/c;
System.out.println(somme);
}
catch (ArithmeticException e)
{
System.out.println("Interdit de diviser par 0 !");
}
}
}

20. Les exceptions
public class Exercice3 {
public static void main (String [] args)
{
int a = 5 ;
int b= 6 ;
int c = 0 ;
try{
int somme = a*b/c;
System.out.println(somme);
}
catch (ArithmeticException e)
{
System.out.println("Interdit de diviser par 0 !");
}
}}

21. Les exceptions
public class Exercice3 {
public static void main (String [] args)
{
int a = 5 ;
int b= 6 ;
int c = 0 ;
On va mettre le code
try{
susceptible de générer une
int somme = a*b/c;
erreur entre le bloc « try »
System.out.println(somme);
}
catch (ArithmeticException e)
{
System.out.println("Interdit de diviser par 0 !");
}
}}

22. Les exceptions
public class Exercice3 {
public static void main (String [] args)
{
int a = 5 ;
int b= 6 ;
int c = 0 ;
Dans le cas d’une exception,
try{
l’action à réaliser dans le bloc
int somme = a*b/c;
« catch »
System.out.println(somme);
}
catch (ArithmeticException e)
{
System.out.println("Interdit de diviser par 0 !");
}
}}

23. Les exceptions
public class Exercice3 {
public static void main (String [] args)
{
int a = 5 ;
Il est possible de prévoir
int b= 6 ;
1 ou plusieurs types d’actions
int c = 0 ;
à réaliser.
try{
int somme = a*b/c;
System.out.println(somme);
}
catch (ArithmeticException e)
{
System.out.println("Interdit de diviser par 0 !");
}
}}

24. Les exceptions
Syntaxe JAVA
try
{
..
}
catch (ClasseException1 variable)
{
…
}
catch (ClasseException2 variable)
{
…
}

25. Les exceptions
Syntaxe JAVA
try
{
Partie de code susceptible de générer une erreur
}
catch (ClasseException1 variable)
{
}
catch (ClasseException2 variable)
{
…
}

26. Les exceptions
Syntaxe JAVA
try
{
Partie de code susceptible de générer une erreur
}
catch (ClasseException1 variable)
{
Action à réaliser si le cas appartient à ClasseException1
}
catch (ClasseException2 variable)
{
…
}

27. Les exceptions
Syntaxe JAVA
try
{
Partie de code susceptible de générer une erreur
}
catch (ClasseException1 variable)
{
Action à réaliser si le cas appartient à ClasseException1
}
catch (ClasseException2 variable)
{
Action à réaliser si le cas appartient à ClasseException2
}

28. Les exceptions
Le bloc finally
Un bloc finally permet au programmeur de définir un
ensemble d'instructions qui est toujours exécuté, que
l'exception soit levée ou non, capturée ou non.
La seule instruction qui peut faire qu'un bloc finally
ne soit pas exécuté est System.exit().

29. Les exceptions
package Exercice; try{
int somme = a*b/c;
public class Exercice3 { System.out.println(somme);
public static void main }
(String [] args) catch (ArithmeticException e)
{
{ System.out.println("Interdit de diviser par 0 !");
int a = 5 ;
int b= 6 ; }
finally
int c = 0 ; {
System.out.println("Bloc Finally!");
}
}
}
Le bloc finally sera exécuté à la fin !

30. Les exceptions
package Exercice; try{
int somme = a*b/c;
public class Exercice3 { System.out.println(somme);
public static void main }
(String [] args) catch (ArithmeticException e)
{
{ System.out.println("Interdit de diviser par 0 !");
int a = 5 ;
int b= 6 ; }
finally
int c = 0 ; {
System.out.println("Bloc Finally!");
}
}
}
Le résultat d’affichage est :
Interdit de diviser par 0 !
Bloc Finally!

31. Les exceptions
Les erreurs les plus fréquentes :
Division par zéro pour les entiers : ArithmeticException
référence nulle : NullPointerException
Type illégale : ClassCastException
Tentative de création d'un tableau de taille négative : NegativeArraySizeException
Dépassement de limite d'un tableau : ArrayIndexOutOfBoundsException
Format non valable : NumberFormatException

32. Les exceptions
Les erreurs les plus fréquentes :
Division par zéro pour les entiers : ArithmeticException
référence nulle : NullPointerException
Type illégale : ClassCastException
Tentative de création d'un tableau de taille négative : NegativeArraySizeException
Dépassement de limite d'un tableau : ArrayIndexOutOfBoundsException
Format non valable : NumberFormatException
Et si nous voulons créer nos propres
exceptions?

33. Les exceptions package unpackage;
package unpackage; public class Passagers {
public class Main {
public static void main(String[] args) { void doNbPassager(int value) throws
Passagers monTrain = new Passagers(); MonExption
try{ {
monTrain.doNbPassager(5); if(value < 0){
monTrain.doNbPassager(7); throw new MonExption(value);
monTrain.doNbPassager(8); }
monTrain.doNbPassager(-12); else {
System.out.println("Nombre correct de passagers : "+value);
} }
catch(MonExption a){ }
System.out.println ("Exception générée par : "+ a );
} }
}
}
package unpackage;
public class MonExption extends Exception {
Les exceptions
MonExption(int v)
{
personnalisées.
System.out.println("Le nombre de passager ne peut pas être
négatif:"+ v);
}
}

34. Les exceptions package unpackage;
package unpackage; public class Passagers {
public class Main {
public static void main(String[] args) { void doNbPassager(int value) throws
Passagers monTrain = new Passagers(); MonExption
try{ {
monTrain.doNbPassager(5); if(value < 0){
monTrain.doNbPassager(7); throw new MonExption(value);
monTrain.doNbPassager(8); }
monTrain.doNbPassager(-12); else {
System.out.println("Nombre correct de passagers : "+value);
} }
catch(MonExption a){ }
System.out.println ("Exception générée par : "+ a );
} }
}
}
package unpackage;
public class MonExption extends Exception { Nous avons 3 classes
MonExption(int v) Main ; Classe principale
{
System.out.println("Le nombre de passager ne peut pas être Passagers : Classe passagers
négatif:"+ v); MonException : Exception Personnalisée
}
}

35. Les exceptions package unpackage;
package unpackage; public class Passagers {
public class Main {
public static void main(String[] args) { void doNbPassager(int value) throws
Passagers monTrain = new Passagers(); MonExption
try{ {
monTrain.doNbPassager(5); if(value < 0){
monTrain.doNbPassager(7); throw new MonExption(value);
monTrain.doNbPassager(8); }
monTrain.doNbPassager(-12); else {
System.out.println("Nombre correct de passagers : "+value);
} }
catch(MonExption a){ }
System.out.println ("Exception générée par : "+ a );
} }
}
}
Etudions un cas où une exception
package unpackage;
public class MonExption extends Exception { n’est pas générée.
MonExption(int v) On appelle la méthode
{
System.out.println("Le nombre de passager ne peut pas être « doNbPassager » avec
négatif:"+ v); « 5 » comme argument.
}
}

36. Les exceptions package unpackage;
package unpackage; public class Passagers {
public class Main {
public static void main(String[] args) { void doNbPassager(int value) throws
Passagers monTrain = new Passagers(); MonExption
try{ {
monTrain.doNbPassager(5); if(value < 0){
monTrain.doNbPassager(7); throw new MonExption(value);
monTrain.doNbPassager(8); }
monTrain.doNbPassager(-12); else {
System.out.println("Nombre correct de passagers : "+value);
} }
catch(MonExption a){ }
System.out.println ("Exception générée par : "+ a );
} }
}
}
package unpackage;
public class MonExption extends Exception { La condition n’est pas respectée.
MonExption(int v)
{
System.out.println("Le nombre de passager ne peut pas être
négatif:"+ v);
}
}

37. Les exceptions package unpackage;
package unpackage; public class Passagers {
public class Main {
public static void main(String[] args) { void doNbPassager(int value) throws
Passagers monTrain = new Passagers(); MonExption
try{ {
monTrain.doNbPassager(5); if(value < 0){
monTrain.doNbPassager(7); throw new MonExption(value);
monTrain.doNbPassager(8); }
monTrain.doNbPassager(-12); else {
System.out.println("Nombre correct de passagers :
} "+value);
catch(MonExption a){ }
System.out.println ("Exception générée par : "+ a ); }
}
} }
}
package unpackage;
public class MonExption extends Exception { On exécute le contenu du bloc else
MonExption(int v)
{
System.out.println("Le nombre de passager ne peut pas être
négatif:"+ v);
}
}

38. Les exceptions package unpackage;
package unpackage; public class Passagers {
public class Main {
public static void main(String[] args) { void doNbPassager(int value) throws
Passagers monTrain = new Passagers(); MonExption
try{ {
monTrain.doNbPassager(5); if(value < 0){
monTrain.doNbPassager(7); throw new MonExption(value);
monTrain.doNbPassager(8); }
monTrain.doNbPassager(-12); else {
System.out.println("Nombre correct de passagers : "+value);
} }
catch(MonExption a){ }
System.out.println ("Exception générée par : "+ a );
} }
}
}
package unpackage;
public class MonExption extends Exception { Etudions un cas où une exception
MonExption(int v)
{ va être levée.
System.out.println("Le nombre de passager ne peut pas être
négatif:"+ v);
}
}

39. Les exceptions package unpackage;
package unpackage; public class Passagers {
public class Main {
public static void main(String[] args) { void doNbPassager(int value) throws
Passagers monTrain = new Passagers(); MonExption
try{ {
monTrain.doNbPassager(5); if(value < 0){
monTrain.doNbPassager(7); throw new MonExption(value);
monTrain.doNbPassager(8); }
monTrain.doNbPassager(-12); else {
System.out.println("Nombre correct de passagers : "+value);
} }
catch(MonExption a){ }
System.out.println ("Exception générée par : "+ a );
} }
}
}
package unpackage;
public class MonExption extends Exception { On appelle la méthode doNbPassager
MonExption(int v)
{ avec comme argument -12
System.out.println("Le nombre de passager ne peut pas être
négatif:"+ v);
}
}

40. Les exceptions package unpackage;
package unpackage; public class Passagers {
public class Main {
public static void main(String[] args) { void doNbPassager(int value) throws
Passagers monTrain = new Passagers(); MonExption
try{ {
monTrain.doNbPassager(5); if(value < 0){
monTrain.doNbPassager(7); throw new MonExption(value);
monTrain.doNbPassager(8); }
monTrain.doNbPassager(-12); else {
System.out.println("Nombre correct de passagers : "+value);
} }
catch(MonExption a){ }
System.out.println ("Exception générée par : "+ a );
} }
}
}
package unpackage;
public class MonExption extends Exception { La condition est respectée. -12 est un
MonExption(int v)
{ nombre négatif.
System.out.println("Le nombre de passager ne peut pas être
négatif:"+ v);
}
}

41. Les exceptions package unpackage;
package unpackage; public class Passagers {
public class Main {
public static void main(String[] args) { void doNbPassager(int value) throws
Passagers monTrain = new Passagers(); MonExption
try{ {
monTrain.doNbPassager(5); if(value < 0){
monTrain.doNbPassager(7); throw new MonExption(value);
monTrain.doNbPassager(8); }
monTrain.doNbPassager(-12); else {
System.out.println("Nombre correct de passagers : "+value);
} }
catch(MonExption a){ }
System.out.println ("Exception générée par : "+ a );
} }
}
}
package unpackage;
public class MonExption extends Exception { On appelle l’exception
MonExption(int v)
{ « MonException » par le biais du mot
System.out.println("Le nombre de passager ne peut pas être clé throw.
négatif:"+ v);
}
}

42. Les exceptions package unpackage;
package unpackage; public class Passagers {
public class Main {
public static void main(String[] args) { void doNbPassager(int value) throws
Passagers monTrain = new Passagers(); MonExption
try{ {
monTrain.doNbPassager(5); if(value < 0){
monTrain.doNbPassager(7); throw new MonExption(value);
monTrain.doNbPassager(8); }
monTrain.doNbPassager(-12); else {
System.out.println("Nombre correct de passagers : "+value);
} }
catch(MonExption a){ }
System.out.println ("Exception générée par : "+ a );
} }
}
}
package unpackage;
public class MonExption extends Exception { Nous arrivons dans la méthode qui
MonExption(int v)
{ permet d’exécuter un message
System.out.println("Le nombre de passager ne peut pas être personnalisé en cas d’exception.
négatif:"+ v);
}
}

43. Les exceptions package unpackage;
package unpackage; public class Passagers {
public class Main {
public static void main(String[] args) { void doNbPassager(int value) throws
Passagers monTrain = new Passagers(); MonExption
try{ {
monTrain.doNbPassager(5); if(value < 0){
monTrain.doNbPassager(7); throw new MonExption(value);
monTrain.doNbPassager(8); }
monTrain.doNbPassager(-12); else {
System.out.println("Nombre correct de passagers : "+value);
} }
catch(MonExption a){ }
System.out.println ("Exception générée par : "+ a );
} }
}
}
package unpackage;
public class MonExption extends Exception { Nous affichons le message.
MonExption(int v)
{
System.out.println("Le nombre de passager ne peut
pas être négatif:"+ v);
}
}

44. Les exceptions package unpackage;
package unpackage; public class Passagers {
public class Main {
public static void main(String[] args) { void doNbPassager(int value) throws
Passagers monTrain = new Passagers(); MonExption
try{ {
monTrain.doNbPassager(5); if(value < 0){
monTrain.doNbPassager(7); throw new MonExption(value);
monTrain.doNbPassager(8); }
monTrain.doNbPassager(-12); else {
System.out.println("Nombre correct de passagers : "+value);
} }
catch(MonExption a){ }
System.out.println ("Exception générée par :
"+ a ); }
}
}
}
package unpackage;
public class MonExption extends Exception { Nous exécutons le message contenu
MonExption(int v)
{ dans le bloc catch. Ce bloc s’exécutera
System.out.println("Le nombre de passager ne peut pas être à chaque fois qu’une exception est
négatif:"+ v);
} attrapée.
}