Vous êtes sur la page 1sur 4

Les Exceptions

Lorsde
Lors del'exécution
l'exécutiond'un
d'unprogramme,
programme,ililexiste
existedes
dessituations
situations
"exceptionnelles" difficiles à gérer correctement
"exceptionnelles" difficiles à gérer correctement : :
–– division
divisionpar
parzéro,
zéro,
LES EXCEPTIONS – accèsaux
– accès auxtableau,
tableau,
–– accès
accèsauxauxfichiers,
fichiers,
– etc…
– etc…

Solutions possibles :
– Ne rien faire. Cela peut causer l'arrêt brutal de l'exécution
(exemple : division by 0 error ! )
– Interrompre l'exécution normale, traiter le problème, puis
reprendre l'exécution.
Gérer l'exception
1 2

Exemple : ne rien faire Exemple : situation intermédiaire


public class Pile {
public class Pile {
// structure de données
// structure de données
private int[ ] tab; // elements de la pile
private int[ ] tab; // elements de la pile
private int taille; // taille de la pile
private int taille; // taille de la pile
//constructeurs
public Pile( ) { this(10); }
//constructeurs
public Pile(int t) {taille=0; tab = new int[t]; }
public Pile( ) { this(10); }
//méthodes
public Pile(int t) {taille=0; tab = new int[t]; }
public boolean estVide( ){return (taille <= 0); }
public boolean estPleine( ){ return (taille >= tab.length); }
//méthodes
public void depiler ( ) { if (! this. estVide()) taille--; }
public boolean estVide( ){return (taille <= 0); }
public void empiler ( int v) {
public boolean estPleine( ){ return (taille >= tab.length); }
if (! this. estPleine()) tab[taille++]=v; }
public void depiler ( ) { taille--; }
public int sommet( ) {
public int sommet( ){ return(tab[taille-1]); }
if (! this.estVide()) return(tab[taille-1]);
public void empiler ( int v) { tab[taille++]=v; }
else return –1; On contourne l'action
}
On ne fait rien }
3 4

Gestion des Exceptions Traiter une exception


La gestion des exceptions nous permet de : Deux mots clés pour traiter une exception :
– Les traiter. Mots clés : try et catch
– Les Lever et Relayer. Mots clés : throw et throws
try
Les Exceptions sont définies à l'aide de classes particulières et le Ce mot clé permet de spécifier une section de code sur laquelle on
programmeur peut s'attend qu'une exception puisse être levée.
– soit les réutiliser, Zone sous
– soit définir ses propres catégories d'exceptions surveillance
catch
Les exceptions sont donc des instances de sous-classes de : Sert à spécifier le code à exécuter si l'exception se produit.
– java.lang.Error (pour des erreurs graves, qui devront catch a comme argument un objet de la exception levée.
généralement conduire à l'arrêt du programme) et
– java.lang.Exception (pour des événements inattendus, qui
pourront être traités).
5 6
Exemple traitement Exemple traitement
public class TestCapture { public class CaptureException {
En-tête de parseInt de la classe Integer :
public static void main(String[] args) { public static int moyenne(String[ ] liste) {
public static int parseInt(String s) throws
int somme = 0, entier, nbNotes = 0; NumberFormatException
System.out.println("La moyenne est " +
for (int i = 0; i < liste.length; i++) {
CaptureException.moyenne(args));
try {
} entier = Integer.parseInt(liste[i]); // traitement exception facultatif
} somme = somme + entier; Les instructions qui suivent le lancement
nbNotes++; de l'exception et intérieures au bloc try
Exemple } sont ignorées
d'exécution : catch (NumberFormatException e) {
System.out.println("La "+(i+1)+" eme note \""+ liste[i] +
"\" n'est pas entiere");
}
} // fin boucle
return somme/nbNotes; Les instructions du bloc catch sont
} exécutées.
} Le programme reprend normalement
avec l'instruction qui suit le catch.
7 8

Quelques exceptions et méthodes Lever et Relayer une exception


Exception Le mot clé throws
Exemples de classes qui
héritent d'Exception : permet de relayer une exception.
IOException

NullPointerException Une méthode susceptible de lever une exception sans la traiter


(l'exception est relayée) doit l'indiquer dans son en-tête.
OutOfMemoryException

ArithmeticException Exemple :
ClassCastException
public void maMethode( ) throws IOException {
ArrayIndexOutOfBoundsException
// corps de la méthode
NumberFormatException
}
Exemples de méthodes applicables sur des objets de classes
qui héritent d'Exception. String toString() Le mot clé throw
permet de lever une exception en instanciant un objet d'une classe qui
void printStackTrace()
9 10 hérite d'Exception. déclencher

Définir sa propre exception Définir sa propre exception


public class ExempleRelaye {
Il suffit de définir une classe qui hérite de la classe Exception. public static int moyenne(String[] liste) throws AucuneNoteException {// relayer
int somme=0,entier, nbNotes=0;
Exemple for ( int i=0; i < liste.length; i++) {
try {
entier = Integer.parseInt(liste[i]);
public class AucuneNoteException extends Exception { somme = somme + entier;
public String toString() { nbNotes++;
return("Aucune note n'est valide"); }
} catch (NumberFormatException e) {
} System.out.println("La " + (i+1 )+ " eme note \""+
liste[i] + "\" n'est pas entiere");
}
} // fin boucle
if (nbNotes==0) throw new AucuneNoteException (); //lever l'exception
return somme/nbNotes;
}
}

11 12
Définir sa propre exception Exemple de Pile
public class TestRelaye { public class Pile {
public static void main(String[ ] args) { …
try { // on capture l'exception pouvant être propagée par moyenne //méthodes
System.out.println("La moyenne est "+ public boolean estVide( ){return (taille <= 0); }
ExempleRelaye.moyenne(args)); public boolean estPleine( ){ return (taille >= tab.length); }
}
public void depiler ( ) throws PileVideException {
catch (AucuneNoteException e) {
if (! this. estVide()) taille--;
System.out.println(e); // e.toString()
} else throw new PileVideException("La pile est vide !");
} }
} public void empiler ( int v) throws PilePleineException {
if (! this. estPleine()) tab[taille++]=v;
Arguments lors de l'exécution : else throw new PilePleineException("La pile est pleine !");
}
public int sommet( ) throws PileVideException {
if (! this.estVide()) return(tab[taille-1]);
else throw new PileVideException("La pile est vide !");
}
}
13 14

Exemple de Pile Les Exceptions : récupération


public class PileException extends Exception { Pile p = new Pile();
public String toString() { return("Erreur manipulation d'une pile !"); } try {
} p.depiler( );
}
public class PileVideException extends PileException {
private String message; catch (PileVideException e) {
public PileVideException(String message) { this.message = message; } System.err.println(e);
public String toString() { return message; }
}
}

public class PilePleineException extends PileException {


// Autre alternative :
private String message;
Pile p = new Pile(); Classe mère de toutes
public PilePleineException(String message) { this.message = message; }
public String toString() { return message; } try { les exceptions
}
p.depiler( );
}
catch (Exception e) { System.err.println(e); }
15 16

Chemin parcouru lors du traitement d'exceptions


Récupération : cas général public class Classe2 { public class Classe1 {
Classe1 objet1 = new Classe1 (); // ...
try {
void methodeX() { void methode1() throws UneException{
operation_risquée1; Région surveillée try { // ...
opération_risquée2;
objet1.methode1(); // En cas d'erreur, déclenchement
}
// ... // d'une exception
catch (ExceptionInteressante e) {
} throw new UneException ();
traitements on traite en catch (UneException exception1) { // ...
}
premier les // Que faire en cas de problème ? }
catch (ExceptionParticulière e) {
exceptions les } }
traitements
}
plus spécifiques // ... Eventuellement d'autres catch (...)
finally {
catch (Exception e) {
// Le bloc finally est optionnel
traitements
}
finaly sera toujours }
finally { exécuté }
void methodeY () throws UneException {
traitement_pour_terminer_proprement;
objet1.methode1 ();
}
// ...
17 18} }
Les Exceptions Les Exceptions : 3 grandes catégories
Quand une exception est générée : Les exceptions de type Error (erreurs non contrôlées) :
– correspondent à des erreurs graves,
 si on est dans "try catch" et si l'exception correspond à un des "catch", – ne peuvent pas être capturées
alors on l'exécute et on continue.
– n'ont pas à être signalées dans la clause throws
 si non on regarde si, dans la méthode appelante, on est dans un try catch
Les exceptions de type RunTimeException (erreurs pouvant
et si l'exception correspond à un des "catch", on l'exécute et on continue
être contrôlées) :
 sinon on regarde si, dans la méthode appelante de la méthode appelante, – peuvent être capturées, mais cela n'est pas obligatoire,
on est dans un try catch . . . – n'ont pas à être signalées dans la clause throws

etc… Les autres Exceptions. Dans leurs méthodes toutes les exceptions
qui peuvent se produire doivent être contrôlées :
 enfin si l'exception n'est pas capturée, on arrête l'exécution du programme… – doivent être signalées dans la clause throws sauf
si elles sont capturées par un try catch
19 20

La hiérarchie des Exceptions La hiérarchie des Exceptions


Throwable

message : string
stackTrace : undefined
getMessage() Nom de la classe
printStackTrace()

hiérarchie
Error Exception

VirtualMachineError RunTimeException
PileException

Les classes de RuntimeException ne sont pas


obligées d'être citées après throws.

NullPointerException IndexOutOfBoundsException
PileVideException PilePleineException

21 22

Exemple de RunTimeException Exemple de RunTimeException


public class ExceptionCastExemple { public class ExceptionCastExemple {
public static void main(String[] args) { public static void main(String[] args) {
Vector v = new Vector(); // Vector vide Vector v = new Vector(); // Vector vide
v.add("Hello"); v.add("Hello"); v.add(new Date());
v.add(new Date()); System.out.println(v.toString());
System.out.println(v.toString()); try { String s1 = (String) v.elementAt(0);
System.out.println("Premier élément : " + s1);
String s1 = (String) v.elementAt(0);
String s2 = (String) v.elementAt(1); // erreur de cast
System.out.println("Premier élément : " + s1);
System.out.println("Premier élément : " + s1);
String s2 = (String) v.elementAt(1); // erreur de cast
}
System.out.println("Premier élément : " + s1); catch (ClassCastException e){ Il y a un erreur, on le
} Il y a un erreur, mais on System.out.println("Erreur :"); capturer
} n'est pas obligé de le System.out.println(e.toString());
capturer System.out.println("Fin erreur.");
}
}
}
23 24

Vous aimerez peut-être aussi