CSI1502 Principes fondamentaux en conception des logiciels Chapter 8: Gestion des exceptions.
Transcript of CSI1502 Principes fondamentaux en conception des logiciels Chapter 8: Gestion des exceptions.
CSI1502Principes 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.javapublic 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.
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.javaimport 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.javawhile (!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.javapublic 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."); }}
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.javapublic 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."); int result = 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.javaimport 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 }}
19
Lancer une exceptionEnter 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: 27End of main method
20
OutOfRangeException.javapublic 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
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