7
Qu’est ce qu’une exception?
▪ Un programme peut échouer pour une raison ou une autre:
o Le code essaie de se connecter à un site web, mais la connexion Internet est interrompue.
o Une erreur dans le code qui consiste à accéder à un tableau avec un index invalide.
o Une méthode appelle une autre avec une valeur que la méthode ne prend pas en charge.
o une ouverture d'un fichier inexistant
▪ Il s’agit de cas “exceptionnels” dans l’exécution du programme
▪ Une exception est une erreur qui se produit, soudainement, lors de l’exécution d’un programme et qui
provoque un fonctionnement anormal de ce dernier (par exemple l'arrêt du programme)
2
▪ Comment lire cette trace?
o Une erreur (exception) s'est produite au niveau de la méthode main(). Cette exception est de type
ArithmeticException, et plus précisément, division par zéro
o L’exception est lancée à la méthode divint() de la classe Div, au niveau de la ligne 3, suite à un appel de la méthode
main de la classe Div, au niveau de la ligne 7
▪ Suite à cette erreur, une exception est lancée/levée (thrown) → un objet de la classe ArithmeticException
est crée, contenant des informations pertinentes à l’erreur. 3
1 package hello;
2 class ExceptionTest {
3 public static void g() {
4 int[] a = new int[5];
5 a[6] = 2;
6 }
7
8 public static void main(String[] args) {
9 g();
10 [Link]("Done!");
11 }
12 }
Exception in thread "main" [Link]: Index 6 out of bounds for length 5
at [Link].g([Link])
at [Link]([Link])
L’exception ArrayIndexOutOfBoundsException est lancée
4
Remarquons que le texte « Done!» n’est pas affiché à cause de l’arrêt du programme
▪ Deux solutions:
o Laisser le programme se terminer avec une exception,
o Essayer, malgré l'exception, de continuer l'exécution normale
• Gestion de l’exception (exception handling)
5
1
2 class ExceptionTest {
3 public static void g() {
4 int[] a = new int[5];
5 try {
6 a[6] = 2;
7 }
8 catch(ArrayIndexOutOfBoundsException e) { Résultat d’exécution:
9 [Link]("Problème");
10 } Problème
11 } Done!
12
13 public static void main(String[] args) {
14 g();
15 [Link]("Done!");
16 }
17 }
▪ Le programme se termine correctement et le texte « Done!» est pas affiché
6
▪ Deux types d’exceptions
o Des exceptions prédéfinies dans l’API java (built-in exceptions)
o Des nouvelles exceptions définies par le programmeur (use-defined exceptions)
• Une nouvelle exception est une sous classe d’une exception Java prédéfinie
7
Checked
▪ Une exception Java est un objet qui hérite de la classe
Unchecked
Throwable ([Link])
▪ Deux sous-classes de Throwable (deux types d’erreur) : Throwable
▪ Error : représente les erreurs graves comme le manque
de mémoire (OutOfMemoryError) ou un problème Exception Error
avec le matériel.
RuntimeException
o Il est impossible de remédier/gérer !
▪ Exception : représente des erreurs gérables comme
une division par zéro ou l’accès à un fichier inexistant.
o Il est possible de remédier/gérer
8
▪ Deux types d’exceptions: Checked
o Checked les exceptions vérifiées au moment de la compilation Unchecked
• Le compilateur peut les détecter avant l’exécution
Throwable
o Unchecked = les exceptions non vérifiée au moment de la compilation
• Le compilateur ne peut pas les détecter.
Exception Error
• Ils sont lancés au cours de l‘exécution (at runtime)
SQLException IOException RuntimeException
ArithmeticException NullPointerException ArrayIndexofBoundsException IllegalArgumentException
9
▪ Ce sont les classes qui héritent de Exception mais pas de RuntimeException
Checked
o Remarque: Les exceptions vérifiées incluent aussi toute classe qui hérite de Throwable,
mais pas Error ni RuntimeException Unchecked
o Mais on s’intéressent uniquement à la première catégorie ( ceux qui héritent de Exception )
▪ Les exceptions vérifiées (checked) doivent être déclarée (delared) Throwable
ou bien gérée (handled) par le code à l’endroit où elles ont été lancée
o sinon erreur de compilation! Exception Error
SQLException IOException RuntimeException
ArithmeticException NullPointerException ArrayIndexofBoundsException IllegalArgumentException
10
1 import [Link];
2 public class MyCheckedException {
3 static void add() {
4 File f = new File("c:\\[Link]");
5 [Link]();
6 }
7
8 public static void main(String[] args) {
9 add();
10 [Link]("end of main !!");
11 }
12 }
▪ Erreur de compilation : unhandled Exception type IOException
▪ IOException est une exception de type checked
▪ A l’endroit où elle a été lancé, l’exception checked doit être :
o déclarée (delared) avec le mot clé throws, ou bien
o gérée (handled) , avec un block catch 11
1 import [Link];
2 import [Link]; ▪ Le code compile bien
3
4 public class MyCheckedException { ▪ l’excéption IOException
5 static void add() {
6 File f = new File("c:\\[Link]"); est gérée (handled) avec un
7 try {
bloque catch
8 [Link]();
9 } ▪ Résultat d’exécution:
10 catch(IOException e) {
11 [Link]("problem catched here"); problem catched here
12 }
13 } end of main !!
14 public static void main(String[] args) {
15 add();
16 [Link]("end of main !!");
17 }
18 }
12
▪ Ce sont les classes qui héritent de RuntimeException et Error Checked
▪ Les exceptions non vérifiées (unchecked) ne sont pas détectables Unchecked
au moment de la compilation
Throwable
Exception Error
SQLException IOException RuntimeException
ArithmeticException NullPointerException ArrayIndexofBoundsException IllegalArgumentException
13
1 package hello;
2 public class MyUncheckedException {
3 static void add() {
4 [Link](5/0);
5 }
6
7 public static void main(String[] args) {
8 add();
9 [Link]("end of main !!");
10 }
11 }
12
▪ Le code compile!
▪ mais, exception à l’exécution:
Exception in thread "main" [Link]: / by zero
at [Link]([Link])
at [Link]([Link])
14
1 package hello;
2 public class MyUncheckedException { ▪ Le code s’exécute sans
3 static void add() {
4 try { exception
5 [Link](5/0);
6 } ▪ Résultat d’exécution:
7 catch(ArithmeticException e) {
division par zero
8 [Link]("dividion par zero");
9 } end of main !!
10 }
11
12 public static void main(String[] args) {
13 add();
14 [Link]("end of main !!");
15 }
16 }
15
▪ Une exception peut être lancée/levée de deux façons :
o Par la JVM :
• Lorsqu'une erreur d'exécution survient dans le programme Java, la JVM lève automatiquement une exception
(par exemple, une RuntimeException).
o Par le développeur :
• Le développeur peut également lever une exception explicitement au sein de son programme, en utilisant une
classe qui hérite de Exception, RuntimeException, etc.
• Utilisation du mot clé throw
16
▪ Lorsque l’on veut lancer une exception, on utilise le mot clé throw suivi de l’exception à lancer
▪ Cette exception doit être d’abord créée avec
new NomException()
o de la même manière que lorsque l’on crée un nouvel objet par un appel à l’un des constructeurs de sa classe
▪ Ainsi lancer une exception de la classe NomException s’écrit :
throw new NomException();
throw new NomException("message d’erreur");
17
Exemple 1
1 package hello;
2 public class Arret {
3 public static void main(String[] args) {
4 [Link]("Coucou 1");
5 if (true)
6 throw new StopException();
7 [Link]("Coucou 2");
8 [Link]("Coucou 3");
9 [Link]("Coucou 4");
10 }
11 }
12 class StopException extends RuntimeException {}
▪ Le programme compile (unchecked) ▪ Cette exception peut être gérée/attrappée en ajoutant
un block catch
▪ Résultat d’exécution:
Coucou 1
Exception in thread "main" [Link]
at [Link]([Link]) 18
Exemple 1 – avec gestion de l’exception
1 package hello; Coucou 1
2 public class Arret { erreur attrapée
3 public static void main(String[] args) { Coucou 2
Coucou 3
4 [Link]("Coucou 1");
Coucou 4
5 if (true){
6 try {
7 throw new StopException();
8 }catch(StopException e) {
9 [Link]("erreur attrapée");
10 }
11 }
12 [Link]("Coucou 2");
13 [Link]("Coucou 3");
14 [Link]("Coucou 4");
15 }
16 }
17 class StopException extends RuntimeException {}
19
Exemple 1 – avec gestion de l’exception et personnalisation du message
1 package hello;
2 public class Arret {
3 public static void main(String[] args) {
4 [Link]("Coucou 1");
5 if (true) {
6 try {
7 throw new StopException("anomalie");
8 }catch(StopException e) {
9 [Link]("erreur attrapée de type: " + [Link]());
10 }
11 } erreur attrapée de type: anomalie
12 [Link]("Coucou 2"); Coucou 2
13 [Link]("Coucou 3"); Coucou 3
14 [Link]("Coucou 4"); Coucou 4
15 }
16 }
17 class StopException extends RuntimeException {
18 public StopException(String message) {
19 super(message);
20 } 20
21 }
Exemple 2
1 package hello;
2 public class Exemple {
3 public static void verifierAge(int age) {
4 if (age < 18) {
5 throw new IllegalArgumentException();
▪ Résultat d’exécution:
6 }
7 [Link]("Âge valide : " + age + " ans."); Exception capturée :
8 }
9 Programme terminé.
10 public static void main(String[] args) {
11 try {
12 verifierAge(15); // Cela lèvera une exception
13 } catch (IllegalArgumentException e) {
14 [Link]("Exception capturée : ");
15 }
16 [Link]("Programme terminé.");
17 }
18 }
21
Exemple 2 – avec personnalisation du message
1 package hello;
2 public class Exemple {
3 public static void verifierAge(int age) {
4 if (age < 18) {
5 throw new IllegalArgumentException("L'âge doit être supérieur ou égal à 18 ans.");
6 }
7 [Link]("Âge valide : " + age + " ans.");
8 }
9
10 public static void main(String[] args) {
11 try {
12 verifierAge(15);
13 } catch (IllegalArgumentException e) {
14 [Link]("Exception capturée : " + [Link]());
15 }
16 [Link]("Programme terminé.");
17 }
18 }
Résultat d’exécution:
Exception capturée : L'âge doit être supérieur ou égal à 18 ans.
22
Programme terminé.
1 package hello;
Exemple 2 – avec affichage de la trace d’exception
2 public class Exemple {
3 public static void verifierAge(int age) {
4 if (age < 18) {
5 throw new IllegalArgumentException("L'âge doit être supérieur ou égal à 18 ans.");
6 }
7 [Link]("Âge valide : " + age + " ans.");
8 }
9 public static void main(String[] args) {
10 try {
11 verifierAge(15);
12 } catch (IllegalArgumentException e) {
13 [Link]();
14 }
15 [Link]("Programme terminé.");
16 }
17 }
Résultat d’exécution:
[Link]: L'âge doit être supérieur ou égal à 18 ans.
at [Link]([Link])
at [Link]([Link])
Programme terminé. 23
▪ L’exception peut être traitée de deux façons:
o par un block catch
• L’exception est traitée localement, dans la méthode ou l’exception a été lancée
o par le mot clé throws ajouté à la signature du méthode
• L’exception est propagée à la méthode appelante
– cette méthode appelante doit à son tour traiter l’exception par un block catch ou une nouvelle propagation par
throws, etc
24
try – catch - finally
try {
//bloc de programme susceptible de provoquer une exception
}catch(TypeException e){
//bloc de traitement de l'exception
}
finally{
/*Le block finally est un block optionnel contenant des instructions qui
seront toujours exécutées quelque soit le résultat du try */
}
25
try – catch - finally
Exemple:
public class ExempleTryCatchFinally {
public static void main(String[] args) {
int[] tableau = {10, 20, 30};
int index = 3; // Un index qui provoque une exception
try {
[Link]("Élément du tableau : " + tableau[index]);
} catch (ArrayIndexOutOfBoundsException e) {
[Link]("Erreur : L'index " + index + " est hors limites du tableau.");
} finally {
[Link]("Fin de l'accès au tableau.");
}
}
}
26
throws
Exemple:
public class ExempleThrows {
public static void main(String[] args) throws ArrayIndexOutOfBoundsException {
int[] tableau = {10, 20, 30};
int index = 3; // Un index qui provoque une exception
[Link]("Élément du tableau : " + tableau[index]);
[Link]("Fin du programme.");
}
}
27
Exercice
▪ Corriger le programme pour que ça compile
class NoMoreCarrotsException extends Exception {}
public class Bunny {
public static void main(String[] args) {
eatCarrot();
}
private static void eatCarrot() throws NoMoreCarrotsException {}
}
public static void main(String[] args) throws NoMoreCarrotsException {
eatCarrot();
}
ou bien
public static void main(String[] args) {
try {
eatCarrot();
} catch (NoMoreCarrotsException e ) {
[Link]("sad rabbit");
}
} 28