Plan
1 Introduction
2 Capture d’exception
3 Exceptions personnalisées
4 Instructions multi-catch
5 Exceptions paramétrées
6 finally
7 Hiérarchie de classes d’exceptions
Introduction
Java
Exception
Erreur qui se produit pendant l’exécution du programme
Impliquant, généralement, l’arrêt d’exécution
Introduction
Java
Comment faire pour poursuivre l’exécution ?
Repérer les blocs pouvant générer une exception
Capturer l’exception correspondante
Afficher un message relatif à cette exception
Continuer l’exécution
Hiérarchie de classes d’exceptions
UML
Hiérarchie de classes d’exceptions
Ob ject
Throwable
Error Exception
RuntimeException
Hiérarchie de classes d’exceptions
Java
Quelle est la différence entre Error et Exception ?
Error
Problème qui se produit principalement en raison du manque de
ressources (mémoire...)
Pas besoin de capturer ce genre de problèmes.
Exception
Problème qui se produit principalement dans le code écrit par les
développeurs.
Certaines peuvent être vérifiées (Checked Exception) et certaines
autres non (Unchecked Exception).
Hiérarchie de classes d’exceptions
Java
Quelle est la différence entre RuntimeException et Exception ?
RuntimeException
Exception non-vérifiée : Pas besoin de la capturer.
Ne peut être détectée par le compilateur.
Exemple : IndexOutOfBoundsException,
ArithmeticException...
Exception
Exception vérifiée : le compilateur nous oblige à capturer
l’exception.
Exemple : SQLException, IOException...
Introduction
Exception : exemple
public class Test {
public static void main(String[] args) {
int x = 5, y = 0;
System.out.print(x / y);
System.out.println("Fin de calcul");
}
}
Introduction
Exception : exemple
public class Test {
public static void main(String[] args) {
int x = 5, y = 0;
System.out.print(x / y);
System.out.println("Fin de calcul");
}
}
Le message affiché à l’exécution
Exception in thread ”main” java.lang.ArithmeticException : / by zero at
test.FirstClass.main(FirstClass.java :4 )
Introduction
Exception : exemple
public class Test {
public static void main(String[] args) {
int x = 5, y = 0;
System.out.print(x / y);
System.out.println("Fin de calcul");
}
}
Le message affiché à l’exécution
Exception in thread ”main” java.lang.ArithmeticException : / by zero at
test.FirstClass.main(FirstClass.java :4 )
Constatation
Le message Fin de calcul n’a pas été affiché
La divisionpar zéro déclenche une exception ArithmeticException
Capture d’exception
Java
Comment faire pour capturer une exception ?
Utiliser un bloc try { ... } catch { ... }
Le try { ... } pour entourer une instruction susceptible de
déclencher une exception
Le catch { ... } pour capturer l’exception et afficher un
message qui lui correspond
Capture d’exception
Java
Exception : exemple
public class Test {
public static void main(String[] args) {
int x = 5, y = 0;
try {
System.out.println(x / y);
} catch (ArithmeticException e) {
System.out.println("Exception : Division par zéro ");
}
System.out.println("Fin de calcul");
}
}
Capture d’exception
Java
Exception : exemple
public class Test {
public static void main(String[] args) {
int x = 5, y = 0;
try {
System.out.println(x / y);
} catch (ArithmeticException e) {
System.out.println("Exception : Division par zéro ");
}
System.out.println("Fin de calcul");
}
}
Message affiché à l’exécution (exception capturée)
Exception : Division par zéro
Fin de calcul
Capture d’exception
Java
Question
Et si on connaissait pas la classe d’exception ?
Capture d’exception
Java
Question
Et si on connaissait pas la classe d’exception ?
Réponse
On peut utiliser la classe Exception : classe mère de toute classe
d’exception.
Capture d’exception
Java
Exemple
public class Test {
public static void main(String[] args) {
int x = 5, y = 0;try {
System.out.println(x / y);
}
catch (Exception e) {
System.out.println("Exception : Division par zéro ");
}
System.out.println("Fin de calcul");
}
}
Capture d’exception
Java
Exemple
public class Test {
public static void main(String[] args) {
int x = 5, y = 0;try {
System.out.println(x / y);
}
catch (Exception e) {
System.out.println("Exception : Division par zéro ");
}
System.out.println("Fin de calcul");
}
}
même message affiché
Exception : Division par zéro
Fin de calcul
Capture d’exception
Java
Utiliser des méthodes de la classe Exception
public class Test {
public static void main(String[] args) {
int x = 5, y = 0;try {
System.out.println(x / y);
}
catch (Exception e) {
System.out.println("Exception : " + e.getMessage());
}
System.out.println("Fin de calcul");
}
}
Capture d’exception
Java
Utiliser des méthodes de la classe Exception
public class Test {
public static void main(String[] args) {
int x = 5, y = 0;try {
System.out.println(x / y);
}
catch (Exception e) {
System.out.println("Exception : " + e.getMessage());
}
System.out.println("Fin de calcul");
}
}
Message affiché
Exception : / by zero
Fin de calcul
Capture d’exception
Utiliser des méthodes de la classe Exception
public class Test {
public static void main(String[]args) {
int x = 5, y = 0;
try {
System.out.println(x / y);
} catch (Exception e){
e.printStackTrace();
}
System.out.println("Fin de calcul");
}
}
Capture d’exception
Utiliser des méthodes de la classe Exception
public class Test {
public static void main(String[]args) {
int x = 5, y = 0;
try {
System.out.println(x / y);
} catch (Exception e){
e.printStackTrace();
}
System.out.println("Fin de calcul");
}
}
Message affiché
java.lang.ArithmeticException : / by zero
at test.FirstClass.main( FirstClass.java :49 )
Fin de calcul
Exceptions personnalisées
Java
On a utilisé quelques exceptions prédéfinies
Exception
ArithmeticException
NullPointerException
Exceptions personnalisées
Java
On a utilisé quelques exceptions prédéfinies
Exception
ArithmeticException
NullPointerException
On peut aussi définir nos exceptions personnalisées.
Exceptions personnalisées
Java
Considérons la classe Adresse suivante
package org.eclipse.model;
public class Adresse {
private String rue;
private String ville;
private String codePostal;
public Adresse(String rue, String codePostal, String ville) {
this.rue = rue;
this.ville = ville;
this.codePostal = codePostal;
}
// ensuite les getters/setters et autres méthodes
}
Exceptions personnalisées
Java
Hypothèse
codePostal doit contenir exactement 5 chiffres.
Exceptions personnalisées
Java
Hypothèse
codePostal doit contenir exactement 5 chiffres.
Comment faire
Créer notre classe d’exception (qui doit étendre la classe
Exception)
Dans le constructeur de Adresse, on lance une exception si
codePostal ne contient pas 5 chiffres
Exceptions personnalisées
Java
Créons l’exception IncorrectCPException dans un package
org.eclipse.exceptions
public class IncorrectCPException extends Exception {
// le constructeur de cette nouvelle exception
public IncorrectCPException() {
super("Le code postal doit contenir exactement 5 chiffres");
}
}
Exceptions personnalisées
Java
Modifions le constructeur de la classe Adresse
public class Adresse {
private String rue;
private String ville;
private String codePostal;
public Adresse(String rue, String ville, String codePostal)
throws IncorrectCPException {
if (codePostal.length() != 5) {
throw new IncorrectCPException();
}
this.rue = rue;
this.ville = ville;
this.codePostal = codePostal;
}
// + les autres méthodes
}
Exceptions personnalisées
Java
Testons tout cela dans le main()
public static void main(String[] args) {
Adresse a = null;
try {
a = new Adresse ("rue de paradis", "Marseille", "1300");
}
catch(IncorrectCPException icpe) {
icpe.printStackTrace();
}
}
Exceptions personnalisées
Java
Testons tout cela dans le main()
public static void main(String[] args) {
Adresse a = null;
try {
a = new Adresse ("rue de paradis", "Marseille", "1300");
}
catch(IncorrectCPException icpe) {
icpe.printStackTrace();
}
}
Message affiché
Le code postal doit contenir exactement 5 chiffres.
Instructions multi-catch
Java
Deuxième hypothèse
codePostal doit contenir exactement 5 chiffres.
rue doit être une chaı̂ne en majuscule.
Instructions multi-catch
Java
Créons une deuxième exception IncorrectStrNameException dans le
package org.eclipse.exceptions
public class IncorrectStrNameException extends Exception {
public IncorrectStrNameException() {
super("La rue doit être en majuscule");
}
}
Instructions multi-catch
Java
Modifions le constructeur de la classe Adresse
public class Adresse {
private String rue;
private String ville;
private String codePostal;
public Adresse(String rue, String ville, String codePostal)
throws IncorrectCPException,IncorrectStrNameException {
if (codePostal.length() != 5) {
throw new IncorrectCPException();
}
if (!rue.equals(rue.toUpperCase())) {
throw new IncorrectStrNameException();
}
this.rue = rue;
this.ville = ville;
this.codePostal = codePostal;
}
}
Instructions multi-catch
Java
Pour tester dans main()
public static void main(String[] args) {
try {
Adresse a = new Adresse ("paradis", "Marseille", "1300");
}
catch(IncorrectCPException icp) {
icp.printStackTrace();
}
catch(IncorrectStrNameException isn) {
isn.printStackTrace();
}
}
Instructions multi-catch
Java
Depuis Java 7, on peut écrire :
public static void main(String[] args) {
try {
Adresse a = new Adresse ("paradis", "Marseille", "1300");
}catch(IncorrectCPException |IncorrectStrNameException e) {
e.printStackTrace();
}
}
Exceptions paramétrées
Java
Question
Comment faire si on voulait afficher les valeurs ayant déclenché
l’exception dans le message ?
Exceptions paramétrées
Java
Modifions la première exception IncorrectCPException
public class IncorrectCodePostalException extends Exception {
public IncorrectCPException(String cp) {
super("Le code postal '" + cp + "' doit contenir 5 chiffres");
}
}
Exceptions paramétrées
Les exceptions paramétrées
Modifions la deuxième exception IncorrectStrNameException
public class IncorrectStreetNameException extends Exception {
public IncorrectStrNameException(String rue) {
System.out.print("La rue '" + rue + "' doit être en
majuscule");
}
}
Exceptions paramétrées
Java
Modifions le constructeur de la classe Adresse
public class Adresse {
private String rue;
private String ville;
private String codePostal;
public Adresse(String rue, String ville, String codePostal)
throws IncorrectCPException,IncorrectStrNameException {
if (codePostal.length()!=5) {
throw new IncorrectCPException(codePostal);
}
if(!rue.equals(rue.toUpperCase())) {
throw new IncorrectStrNameException(rue);
}
this.rue = rue;
this.ville = ville;
this.codePostal = codePostal;
}
}
Exceptions paramétrées
Java
Pour tester
public static void main(String[] args) {
try
{
Adresse a = new Adresse ("paradis", "Marseille", "1300");
}
catch(IncorrectCPException | IncorrectStrNameException e){
e.printStackTrace();
}
}
Exceptions paramétrées
Java
Pour tester
public static void main(String[] args) {
try
{
Adresse a = new Adresse ("paradis", "Marseille", "1300");
}
catch(IncorrectCPException | IncorrectStrNameException e){
e.printStackTrace();
}
}
Message affiché
Le code postal ’1300’ doit contenir exactement 5 chiffres.
finally
Java
finally
À utiliser quand on veut exécuter une instruction qu’une exception
soit levée ou non
finally
Java
Exemple
public class Test {
public static void main(String[] args) {
int x = 5, y = 0;
try {
System.out.println(x / y);
}
catch (Exception e) {
System.out.println("Division par zéro");
}
finally {
System.out.println("Instruction toujours exécutée");
}
}
}
finally
Java
Question
Quelle différence entre le code de finally et le code après try ...
catch ?
finally
Java
Question
Quelle différence entre le code de finally et le code après try ...
catch ?
Réponse
Le code de finally s’exécute même si try et/ou catch contiennent
un return qui forcera l’arrêt de l’exécution du code (et donc le
non-exécution du code situé après try ... catch).
Exceptions paramétrées
Java
Atelier
I c
EL H
Créer la Classe Etudiant qui a les attributs suivants : Nom, Prénom,
Age, Note
M OU
E
Créer ensuite plusieurs objet
f L type Etudiant tout en donnant la
de
e
main à l’utilisateur derrenseigner les informations des étudiants.
Ach
Maintenant vous devez gérer le cas ou l’utilisateur saisi une valeur
incorrect pour l’age:
- Gérer le cas ou il a saisie une chaine de caractère par exemple
Créer de nouvelles exceptions qui se déclenchent si l’utilisateur saisi
- une valeur note négatif ou supérieur à 20
- un l’age qui est inférieur à 10
