Gestion des exceptions Que sont les Exceptions?

1
CSI1502
Principes fondamentaux en
conception des logiciels
Chapter 8:
Gestion des exceptions
2
Objectifs du cours:
Gestion des exceptions
Comprendre ce qui suit:
Le fonctionnement de «try-catch»
Propagation d`exception
Créer et lancer les exceptions
types de «I/O stream»
Étudiez la section 8.0 pour l`examen final
3
Que sont les Exceptions?
Une exception est un objet qui décrit une situation anormal
ou erronée; tel que l`abus
Exceptions sont lancé (« thrown» ) par un programme, et
peuvent être attrapé et utilisé par une autre partie du
programme
Un programme peut-être séparé en:
Un flux normal d`exécution
Un flux d` exception d`exécution
Une error est aussi représenté dans Java comme objet
mais en général représente une situation sans retour et ne
devrait pas être attrapée 4
Prise en charge d`Exception
en Java
Java utilise une ensemble prédéfini d`exceptions et
d`erreurs qui peuvent arriver durant l`exécution
Un programme peut s`occuper d`une
exception d`une de 3 façons:
L`ignorer
S`en occuper là ou elle arrive
S`en occuper dans une autre place dans le programme
La manière dont l`exception est traité est un aspect
important de conception
5
Prise en charge d`Exception
en Java
Le message inclus une pile d`appel qui incluse la ligne ou
l`exception à eu lieu
La pile d`appel montre aussi quels sont les méthodes (et
leur ordre d`invocation) qui ont crée cette situation
La méthode getMessage retourne un String expliquant
pourquoi l`exception à été lancé
La méthode printStackTrace imprime la pile
d`appel
Voir Zero.java (p.449)
6
Zero.java
public class Zero
{// Deliberately divides by zero to produce an exception.
public static void main (String[] args)
{int numerator = 10;
int denominator = 0;
System.out.println (numerator / denominator);
System.out.println ("This text will not be printed.");
}
}java.lang.ArithmeticException: / by zero
at Zero.main(Zero.java:17)
Exception in thread "main"
----jGRASP wedge2: exit code for process is 1.
----jGRASP: operation complete.

2
7
Prise en charge d`Exception :
La commande «try»
Afin de s`occuper d`une exception quand elle
arrive, l`on met la ligne qui lance l`exception dans un
block
try
Un block try est suivie de un ou plus de clause catch qui
s`occupent de l`exception
Chaque clause catch à une type exception associé, et
est dénommé une «
exception handler»
Quand une exception prend place, la 1ère clause catch
dont le type d`exception correspond s`en occupe
Voir ProductCodes.java (page xxx) 8
ProductCodes.java
import cs1.Keyboard;
public class ProductCodes
{// Counts the number of product codes that are entered with a
// zone of R and district greater than 2000.
//-----------------------------------------------------------------
public static void main (String[] args)
{String code;
char zone;
int district, valid = 0, banned = 0;
System.out.print ("Enter product code (XXX to quit): ");
code = Keyboard.readString();
Continued…
9
ProductCodes.java
while (!code.equals ("XXX"))
{try
{zone = code.charAt(9);
district = Integer.parseInt(code.substring(3, 7));
valid++;
if (zone == 'R' && district > 2000)
banned++;
}
catch (StringIndexOutOfBoundsException exception)
{System.out.println ("Improper code length: " + code);
}
catch (NumberFormatException exception)
{System.out.println ("District is not numeric: " + code);
}
System.out.print ("Enter product code (XXX to quit): ");
code = Keyboard.readString();
}
System.out.println ("# of valid codes entered: " + valid);
System.out.println ("# of banned codes entered: " + banned); }} 10
La Clause finally
La commande try peut avoir une clause optionnelle suivant
les clause catch, dénommé par le mot réservé finally
Le code dans la clause finally sont toujours exécuté
Si il n`y a pas d`exception de lancé, le code dans la
clause finally est exécuté après que le code du block try
ai été exécuté
Si il y a eu une expection de lancée,If an exception is
generated, le code dans la clause finally est exécuté
après que le code de la clause catch approprié ai été
exécuté
11
Propagation d`exception
Une exception peut-être prise en charge à un niveau plus
haut si il n`est pas approprié de s`en occuper quand elle
arrive
Les exceptions se propagent vers le haut dans la
méthode appelant la hiérarchie jusqu`a ce que elles sont
attrapée et prises en charge ou jusqu`a ce que il
atteigne la méthode main
Un block try qui contient un appel à la méthode dans
laquelle une exception est lancé, peut attraper celle-ci
Voir Propagation.java (page xxx)
Voir ExceptionScope.java (page xxx)
12
Propagation.java
public class Propagation
{
// Invokes the level1 method to begin the exception demonstation.
static public void main (String[] args)
{ExceptionScope demo = new ExceptionScope();
System.out.println("Program beginning.");
demo.level1();
System.out.println("Program ending.");
}
}

3
13
Propagation:
L`imprimé
The call stack trace:
java.lang.ArithmeticException: / by zero
at ExceptionScope.level3(ExceptionScope.java:54)
at ExceptionScope.level2(ExceptionScope.java:41)
at ExceptionScope.level1(ExceptionScope.java:18)
at Propagation.main(Propagation.java:17)
Level 1 ending.
Program ending.
14
ExceptionScope.java
public class ExceptionScope
{//-----------------------------------------------------------------
// Catches and handles the exception that is thrown in level3.
//-----------------------------------------------------------------
public void level1()
{System.out.println("Level 1 beginning.");
try
{level2();
}
catch (ArithmeticException problem)
{System.out.println ();
System.out.println ("The exception message is: " +
problem.getMessage());
System.out.println ();
System.out.println ("The call stack trace:");
problem.printStackTrace();
System.out.println ();
}
System.out.println("Level 1 ending."); } Continued..
15
ExceptionScope.java
public void level2()
{System.out.println("Level 2 beginning.");
level3 ();
System.out.println("Level 2 ending.");
}
//-----------------------------------------------------------------
// Performs a calculation to produce an exception. It is not
// caught and handled at this level.
//-----------------------------------------------------------------
public void level3 ()
{int numerator = 10, denominator = 0;
System.out.println("Level 3 beginning.");
intresult= numerator/ denominator;
System.out.println("Level 3 ending.");
}
}16
L`Hiérarchie de classe
d`exception
Figure 8.1 p.458
17
Prise en charge d`Exception :
la commande throw
Un programmeur peut définir une exception par extension
de la classe Exception class ou l`un de ces descendants
Les exceptions sont lancé en utilisant la commande
thrown
En général un commande throw est intégré dans un
commande if qui évalue la condition pour voir si une
exception devrait être lancée
See CreatingExceptions.java (page xxx)
See OutOfRangeException.java (page xxx) 18
CreatingExceptions.java
import cs1.Keyboard;
public class CreatingExceptions
{//-----------------------------------------------------------------
// Creates an exception object and possibly throws it.
//-----------------------------------------------------------------
public static void main (String[] args) throws OutOfRangeException
{final int MIN = 25, MAX = 40;
OutOfRangeException problem =
new OutOfRangeException ("Input value is out of range.");
System.out.print ("Enter an integer value between " + MIN +
" and " + MAX + ", inclusive: ");
int value = Keyboard.readInt();
// Determines if the exception should be thrown
if (value < MIN || value > MAX)
throw problem;
System.out.println ("End of main method."); // may never reach
}
}

4
19
Lancer une exception
Enter an integer value between 25 and 40, inclusive: 3
OutOfRangeException: Input value is out of range.
at
CreatingExceptions.main(CreatingExceptions.java:18)
Exception in thread "main"
----jGRASP wedge2: exit code for process is 1.
----jGRASP: operation complete.
Enter an integer value between 25 and 40, inclusive: 27
End of main method
20
OutOfRangeException.java
public class OutOfRangeException extends Exception
{//-----------------------------------------------------------------
// Sets up the exception object with a particular message.
//-----------------------------------------------------------------
OutOfRangeException (String message)
{super (message);
}
}
L`utilisation d`une exception, une condition, une
boucle est un choix important dans la conception
21
«Checked Exceptions»
Une exception est soit «checked» ou «unchecked»
Une checked exception doit soit être attrapée par une
méthode ou doit être encapsulé dans une clause
throw de n`importe quel méthode qui peut la lancer
ou propager
Une clause throws est rajouté à l`entête d`une
méthode
Le compilateur va se plaindre si une checked
exception n`est pas prise en main correctement
22
«Unchecked Exceptions»
Une unchecked exception n`a pas besoin d`avoir une
prise en charge implicit, même si l`on peut s`en
occuper de tel façon
Les seuls unchecked exceptions en Java sont des
objets de types RuntimeException ou les
descendants de cette classe
Erreurs sont similaires pour RuntimeException et
les descendants de cette classe
Les erreurs ne devraient pas être attrapées
Les erreurs ne nécessitent pas de clause throw
23
I/O standard
Il y a 3 flux I/O standards:
Entrée standard – défini par System.in
Sortie standard – défini par System.out
Erreur standard – défini par System.err
System.in représente les entrée par clavier
typiquement
System.out et System.err représente une
fenêtre typiquement
Nous utilisons System.out avec la commande
println
Voir p.461+ du livre 24
La classe IOException
Les opérations suivantes utilisant les classes I/O
peuvent lancer une IOException
Un fichier que l`on veut lire ou dans lequel on
veut écrire n`existe pas
Même si le fichier existe, un programme ne
pourrait peut-être pas le trouver
Le fichiers pourrait contenir des donnés dans le
mauvais format
Une IOException est une checked exception

5
25
Chapter 8:
Summary
Comprendre ce qui suit:
Le fonctionnement de «try-catch»
Propagation d`exception
Créer et utiliser les exceptions
types de «I/O stream»
Étudiez la section 8.0 pour l`examen final