Les Exceptions

Concepts
• Erreur & Exception
– Erreur: Un erreur logique impossible de réparer (division par
zéro par exemple)
– Exception: un événement imprévu
• Laisser l’exception sans traiter (échec du programme)
• Traiter l’exception (le programme continue après le traitement)
• Traitement d’exception
– Un contrôle de sécurité
• Appel d’une méthode dans de bonnes conditions ?
• Exécution de la méthode, est-ce qu’elle se déroule correctement ?
• …
• Sinon, quelles alternatives, correction ?
– Mécanisme de traitement: général (classe) pour faciliter les
traitements
 Échec d’un programme
• Impossibilité pour le système d’accomplir une
tâche
• 2 raisons d’échec
– Erreur logique dans l’implantation (la faute du
programmeur)
– Impossibilité d’obtenir des ressources nécessaires
(e.g. fichier)
• Dans le cas d’erreur, pas réparable (seulement
un message d’erreur)
• Mais pour la second classe: possible de traiter
 Ressources nécessaires
• Matériel
• Système d’exploitation
• Fichiers
• Réseau
• Base de données
• Utilisateur (interaction)
 Exception
• Apparition d’une situation anormale,
détectable, qui conduit à l’échec du
programme
• Possibilité pour un programme de détecter
et traiter certaines exceptions pour éviter
l’échec du programme
 Exemple
public class Lecture_mot {
static BufferedReader input;

public static void main(String[] args) {

ouvrir_fichier("liste_mots");

traiter_fichier();
Si on utilise juste cette
fermer_fichier();
}
ligne, et que "liste_mots"
n’existe pas - une
// ouverture du fichier exception non traitée, le
public static void ouvrir_fichier(String nom) { programme échoue
try {
input = new BufferedReader(
new FileReader(nom));
}
catch (IOException e) {
System.err.println("Impossible d'ouvrir le fichier d'entree.\n" +
Possibilité de traiter
e.toString()); l’exception ici,
System.exit(1); e.g. demander à
} l’utilisateur d’entrer un
} // ouvrir_fichier
autre fichier
 Message d’exception
…
catch (IOException e) {
System.err.println("Impossible d'ouvrir le fichier d'entree.\n" +
e.toString());
System.exit(1);
}

Message affiché:

Impossible d'ouvrir le fichier d'entree.

java.io.FileNotFoundException: liste_mots (No such file or directory)
 Mécanisme général en Java
• Permet de détecter, signaler ou traiter une
exception
• Non pour traiter des situations prévues
• N’est pas un mécanisme de contrôle pour
le branchement d’un programme (if, …)
– Mais plutôt un autre mécanisme qui contrôle
l’exécution
 Mécanisme général
• Exemples d’exemption
– Diviser par 0
– Accéder un tableau avec un index invalide
Méthode qui appelle:
…
appel
Appel Méthode appelée:
…
Suite Retour normal
normale
Normal
Traiter
l’exception Exception
… Message d’exception
 Mécanisme général
• Deux mécanismes en parallèle
– Traitement normal
– Traitement d’exception (exception handler)
• Quand il y a une exception
– Le traitement normal s’arrête
– Le traitement d’exception prend le contrôle
 Traitement d’exception en chaîne
• méthode_1 appelle méthode_2, qui appelle
méthode 3
Méthode_1 Méthode_2 Méthode_3

• Si méthode 3 génère une exception

– Message d’exception est envoyé à méthode_2
– Méthode_2 peut
• Traiter (attraper) l’exception
• Relancer l’exception: le message d’exception sera envoyé à
méthode_1
• …
• Si une exception n’est traitée par aucune méthode qui appelle:
sortie du programme avec un message d’exception
Exemple de transmission
d’exception
 Générer une exception
• Certaines exceptions standard sont reconnues
– ArithmeticException: diviser par 0
– ClassCastException: Casting d’un objet à une
mauvaise classe
– EOFException: Lire après la fin d’un fichier
– IllegalArgumentException: paramètres illégaux ou
inappropriés
–…
• Quand une de ces exceptions est rencontrée, le
système lance (throw) un message d’exception
Hiérarchie des classes d’exceptions
                                                                                                                                                                                                                                        
 Attraper (catch) une exception
• Attraper une exception pour la traiter
Bloc où une
try {
exception peut être
statements
: générer
:
} catch ( ExceptionClass1 object) {
statements
:
:
} catch (ExceptionClass2 object) {
statements Blocs pour attraper
: les exceptions
:
}…
 Exemple
public static void ouvrir_fichier(String nom) {
try {
input = new BufferedReader(
new FileReader(nom));
}
catch (IOException e) {
System.err.println("Impossible d'ouvrir le fichier d'entree.\n" +
e.toString());
System.exit(1);
}

}
 Exécution avec catch
• Si aucune exception est générée (thrown), les
instructions dans catch ne sont pas exécutées
• Si une exception est générée, l’exception est comparée
dans l’ordre avec les clauses de catch (ExceptionClass
object)
– Si la classe de l’exception match celle de catch:
• exécution des instruction de ce catch,
• continue après le dernier catch (sauter les autres catches)
– Seulement le premier catch compatible avec l’exception est
exécuté
• Important: Catch d’abord les sous-classes d’exception
– Si aucun catch est compatible avec l’exception,
• l’exception n’est pas attrapée (non traitée)
• transmise à la méthode qui appelle
 Checked vs. Unchecked
• Checked exception
– Vérifiée par le compilateur
– Si le programme peut générer une telle exception, il doit
• Soit la traiter dans le programme
• Soit la retransmettre à l’appelant (avec throws dans l’entête)
– Typiquement générée à cause de l’environnement
– Exemple, IOException
– public void getSomeData () throws FileNotFoundException,
SecurityException
• Unchecked exception
– De type RuntimeException ( ou l’une de ses classes filles, diapo 14)
– Problème du programmeur (mauvaise utilisation d’une méthode,
d’un objet, …)
– Le compilateur ne la vérifie pas
– Si un programme peut générer une telle exception, le programme
n’a pas à la signaler dans l’entête
– public int division(înt a, int b) {return a/b; }
Checked vs. Unchecked exception
 Lancer une checked exception
• Signaler au compilateur qu’une méthode peut
lancer une exception (non attrapée, non traitée)
public void methode() throws ExceptionClass
• Exemple
public void skip () throws IOException {
String s;
s = input.readLine();
}
• Si une exception apparaît, elle est transmise à l’appelant
(caller)
 Traitement partiel d’exceptions
On peut se faire un traitement partiel en faisant un nettoyage ensuite
relancer l’exception à l’appelant.

public void getSomeData () throws

FileNotFoundException, SecurityException{
FileReader in;
try {
in = new FileReader (“DataFile”);
…
} catch (FileNotFoundException e) {
//cleanup
throw e; // throws it again to its caller
}
} catch (SecurityException e) {
//cleanup
throw e; // throws it again to its caller
}
 Le bloc finally
• Exécuter un bloc quel que soit l’exception
try{
instruction(s)
……
}
catch(……){
instruction(s)
……
} Le bloc finally est exécuter même
finally{ si le bloc try ne lance pas
instruction(s) d’exception
……
}
Générer une exception explicitement
• Un programme peut aussi générer une exception
public class BankAccount throws IllegalArgumentException
{
public void withdraw(double amount)
{
if (amount > balance)
{
IllegalArgumentException exception
= new IllegalArgumentException("Amount exceeds balance");
throw exception;
}
balance = balance - amount;
}
...
}
• Général: throw exceptionObject;
• Forcer la méthode qui appelle de traiter cette exception
 Définir ses propres exceptions
• Les classes d’exception prédéfinies ne sont pas
suffisamment explicites
• On a besoin de faire la différence entre les exceptions
pour leurs traitements
• Définir une sous-classe d’exception

public class NoDataException extends Exception {

public NoDataException () {
super();
constructeurs
}
public NoDataException (String s) {
super(s);
}
}
• Définir une hiérarchies de classes d’exception
 Un autre exemple
class TemperatureException extends Exception {
}

class TooColdException extends TemperatureException {

}

class TooHotException extends TemperatureException {

}
 Classe Exception
• Constructeurs
Exception()
Constructs a new exception with null as its detail message.

Exception(String message)
Constructs a new exception with the specified detail message.

Exception(String message, Throwable cause)

Constructs a new exception with the specified detail message
and cause.

Exception(Throwable cause)
Constructs a new exception with the specified cause and a detail
message of (cause==null ? null : cause.toString()) (which typically
contains the class and detail message of cause).
 Classe Throwable
• 4 constructeurs
• Thrwoable getCause()
– Cause de cette exception (ou null)
• String getMessage():
– message envoyé par l’exception
• String toString()
– Générer un message décrivant l’exception
• …
Penser Exception comme des
classes / sous-classes
Une TooColdException
est aussi une
TempretureException,
Exception, Throwable

Attention aux catches:

Catch une sous-classe
avant une super-classe