LMI 2. Programmation Orientée Objet POO - Cours 7. Said Jabbour. jabbour@cril.univ-artois.fr

Transcription

1 LMI 2 Programmation Orientée Objet POO - Cours 7 Said Jabbour jabbour@cril.univ-artois.fr CRIL UMR CNRS 8188 Facult e des Sciences - Univ. Artois Janvier 2011

2 Exceptions

3 Génération et gestion d exceptions 1 Exception : condition anormale survenant lors de l exécution. 2 Lorsqu une exception survient : un objet représentant cette exception est créé ; cet objet est jeté (thrown) dans la méthode ayant provoqué l erreur. 3 Cette méthode peut choisir : de gérer l exception elle-même, de la passer sans la gérer. De toutes façons l exception est captée (caught) et traitée, en dernier recours par l environnement d exécution Java.

4 Génération et gestion d exceptions (suite) 1 Les exceptions peuvent être générées par l environnement d exécution Java, manuellement par du code. 2 Les exceptions jetées (ou levées) par l environnement d exécution résultent de violations des règles du langage ou des contraintes de cet environnement d exécution.

5 Les 5 mots clés 1 Il y a 5 mots clés d instructions dédiées à la gestion des exceptions : try, catch, throw, throws et finally. 2 Des instructions où l on veut surveiller la levée d une exception sont mises dans un bloc précédé de l instruction try. 3 Le code peut capter cette exception en utilisant catch et la gérer.

6 Les 5 mots clés (suite) 1 Les exceptions générées par le système sont automatiquement jetées par l environnement d exécution Java. Pour jeter une exception manuellement, utiliesr throw. 2 Toute exception qui est jetée hors d une méthode doit être spécifiée comme telle avec throws. 3 Tout code qui doit absolument être exécuté avant qu une méthode ne retourne est placé dans un bloc finally.

7 Schéma Le schéma est donc try { // bloc de code a surveiller catch (EceptionType1 exceptobj) { // gestionnaire d exception pour ExceptionType1 catch (EceptionType2 exceptobj) { // gestionnaire d exception pour ExceptionType2... finally { // bloc de code a executer // avant de sortir de la methode

8 Types d exceptions 1 Une classe est au sommet de la hiérarchie des exceptions : Throwable 2 Deux sous-classes de Throwable : Exception : conditions exceptionnelles que les programmes utilisateur devraient traiter. Error : exceptions catastrophiques que normalement seul l environnement d exécution devrait gérer. 3 Une sous-classe d Exception, RuntimeException, pour les exceptions de l environnement d exécution.

9 Objets exceptions En java les exceptions sont des objets toute exception doit être une instance d une sous-classe de la classe java.lang.throwable Throwable Error Exception LinkageError RunTimeException IOException MyException1 ArrayIndexOutOfBounds Exception EOFException FileNotFoundException MyException2

10 Objets exceptions Puisqu elles sont des objets les exceptions peuvent contenir : des attributs particuliers, des méthodes. Attributs et méthodes standards (définis dans java.lang.throwable) Throwabe String message contient un message d erreur Throwable cause décrivant l exception Throwable() Constructeurs (sans et Throwable(String s) avec message d erreur) Throwable(Throwable cause) String getmessage() renvoie le message d erreur décrivant l exception void printstacktrace() affiche sur la sortie erreur standard la liste des appels de méthodes ayant conduit à l exception (backtrace). Throwable getcause()

11 Objets exceptions Structuration de la description des exceptions Exception IOException EOFException FileNotFound Exception ZipException Les exceptions étant des objets, leur structuration en une hiérarchie de classes permet de les traiter à différents niveaux d abstraction (via polymorphisme)

12 Traitement On peut être amené à définir une hiérarchie de classes (sans nécessairement définir de nouveaux attributs et nouvelles méthodes) uniquement dans un souci de structuration et de typage des exceptions class CompteException extends Exception { private int nocompte; public CompteException(int c, String mess) { super(mess); nocompte = c; public int nocompte() { return nocompte; class CompteNotFoundException extends CompteException { public CompteNotFoundException(int c, String mess) { super(c,mess); class CompteOpException extends CompteException { public CompteOpException(int c, String mess) { super(c,mess);

13 Exceptions non gérées 1 Considérons le code suivant où une division par zéro n est pas gérée par la programme : class ExcepDiv0 { public static void main(string args[]) { int d = 0; int a = 42 / d; 2 Lorsque l environnement d exécution essaie d exécuter la division, il construit un nouvel objet exception afin d arrêter le code et de gérer cette condition d erreur. 3 Le flux de code est alors interrompu et la pile d appels (des différentes méthodes invoquées) est inspectée en quête d un gestionnaire d exceptions.

14 Exceptions non gérées (suite) 1 N ayant pas fourni de gestionnaire au sein du programme, le gestionnaire par défaut de l environnement d exécution se met en route. 2 Il affiche la valeur en String de l exception et la trace de la pile d appels : > java ExcepDiv0 java.lang.arithmeticexception: / by zero at ExcepDiv0.main(ExcepDiv0.java:4)

15 Instructions try et catch 1 Un bloc try est destiné à être protégé, gardé contre toute exception susceptible de survenir. 2 try{... délimite un ensemble d instructions susceptibles de déclencher une(des) exception(s) pour la(les)quelles une gestion est mise en oeuvre 3 Juste derièrre un bloc try, il faut mettre un bloc catch qui sert de gestionnaire d exception. Le paramètre de l instruction catch indique le type et le nom de l instance de l exception gérée. 4 cette gestion est réalisée par des blocs catch(typedexception e){... qui suivent le bloc try 5 permettent d intercepter ( attraper ) les exceptions dont le type est spécifié et d exécuter alors du code spécifique.

16 Instructions try et catch (suite) 1 class ExcepDiv0 { public static void main(string args[]) { try { int d = 0; int a = 42 / d; catch (ArithmeticException e) { System.out.println("Div par zero"); 2 La portée d un bloc catch est restreinte aux instructions du bloc try immédiatement précédent

17 Instructions catch multiples 1 On peut gérer plusieurs exceptions à la suite l une de l autre. 2 Lorsqu une exception survient, l environnement d exécution inspecte les instructions catch les unes après les autres, dans l ordre où elles ont été écrites. 3 Il faut donc mettre les exceptions les plus spécifiques d abord.

18 Traitement un bloc try est suivi par une ou plusieurs clauses catch qui permettent d intercepter ( attraper ) les exceptions dont le type est spécifié (dans la clause catch) et d exécuter alors du code spécifique. un seul bloc catch peut être exécuté : le premier suceptible d attraper l exception. chaque clause catch doit être déclarée avec un argument de type Throwable ou une sous-classe de Throwable quand une exception est levée dans le bloc try, la première clause catch dont le type de l argument correspond à celui de l exception levée est invoquée clause catch dont l argument est de même classe que l exception levée, clause catch dont l argument est une super-classe de la classe de l exception levée. l ordre des blocs catch est donc très important.

19 Traitement Except3 (hérite de) Except2 (hérite de) Except1(hérite de) Exception... try { // séquence de code pouvant lever //des exceptions de type Except1, // Except2 ou Except3... catch (Except1 e1){ // e1 est l exception qui a été levée // dans le bloc try System.out.println(e1.getMessage()); e1.printstacktrace(); //... catch (Except2 e2){//... catch (Except3 e3){//... quel bloc catch va la traiter?

20 Traitement pas nécessaire d avoir clause catch pour chaque type possible d exception pouvant être levée. si aucun block catch ne permet d attraper l exception, celle-ci est propagée vers la méthode appelante qui a alors la charge de la trater ou non si une exception n est attrapée par aucune des méthodes présentes dans la pile des appels alors un message d erreur ainsi que la trace de la pile d appels sont affichés et l exécution du programme est interrompue.... try { // séquence de code pouvant lever des exceptions de type Except1, Except2, Except3 ou Except4 catch (Except1 e1){ //... Except3 (hérite de) Except2 (hérite de) Except1 (hérite de) Exception Except4 (hérite de) Exception les exceptions de type Except4 seront reportées au niveau de la méthode appelante

21 Instruction finally les clauses catch sont suivies de manière optionnelle par un bloc finally qui contient du code qui sera exécuté quelle que soit la manière dont le bloc try a été quitté le bloc finally permet de spécifier du code dont l exécution est garantie quoi qu il arrive : le bloc try s exécute normalement sans qu aucune exception ne soit levée la fin du bloc try a été atteinte, contrôle quitte le bloc try suite à une instruction return, continue, break (d ou parfois l utilisation d un bloc try avec un bloc finally sans clauses catch). le bloc try lève une exception attrapée par l un des blocs catch. le bloc try lève une exception qui n est attrapée par aucun des blocs catch qui le suivent.

22 Instruction finally 1 Un bloc finally est toujours exécuté, qu une exception ait été générée ou non. Il est exécuté avant l instruction suivant le bloc try précédent. 2 Si le bloc try précédent contient un return, le bloc finally est exécuté avant que la méthode ne retourne. 3 Ceci peut être pratique pour fermer des fichiers ouverts et pour libérer diverses ressources. 4 Le bloc finally est optionnel.

23 Instruction finally interêt double : permet de rassembler dans un seul bloc un ensemble d instructions qui autrement auraient du être dupliquées permet d effectuer des traitements après le bloc try, même si une exception a été levée et non attrapée par les blocs catch... try { // ouvrir un fichier // effectuer des traitements // susceptibles // de lever une exception // fermer le fichier catch (CertaineException e){ // traiter l exception // fermer le fichier catch (AutreTypeException e){ // traiter l exception // fermer le fichier Le block finally est toujours exécuté... try { // ouvrir un fichier // effectuer des traitements //susceptibles // de lever une exception catch (CertaineException e){ // traiter l exception catch (AutreTypeException e){ // traiter l exception finally { //fermer le fichier

24 Instruction throw 1 Elle permet de générer une exception, via un appel de la forme trow TrhowableInstance ; 2 Cette instance peut être crée par un new ou être une instance d une exception déja existante. 3 Le flux d exécution est alors stoppé et le bloc try immédiatement englobant est inspecté, afin de voir s il possède une instruction catch correspondante à l instance générée. 4 Si ce n est pas le cas, le 2 ième bloc try englobant est inspecté ; et ainsi de suite.

25 Instruction throw (suite) 1 Exemple class ThrowDemo { static void demoproc() { try { throw new NullPointerException("demo"); catch (NullPointerException e2) { System.out.print("attrapee ds demoproc()"); throw e2; public static void main(string args[]) { try { demoproc(); catch(nullpointerexception e1) { System.out.print("attrapee ds main()");

26 Instruction throws 1 Si une méthode est susceptible de générer une exception qu elle ne gère pas, elle doit le spécifier, de façon que ceux qui l appellent puissent se prémunir contre l exception. 2 L instruction throws est utilisée pour spécifier la liste des exceptions qu une méthode est susceptible de générer. 3 Pour la plupart des sous-classes d Exception, le compilateur forcera à déclarer quels types d exception peuvent être générées (sinon, le programme ne compile pas). 4 Cette règle ne s applique pas à Error, RuntimeException ou à leurs sous-classes.

27 Instruction throws (suite) 1 L exemple suivant ne compilera pas : class ThrowsDemo1 { static void proc() { System.out.println("dans proc()"); throw new IllegalAccessException("demo"); public static void main(string args[]) { proc(); Ce programme ne compilera pas : parce que proc() doit déclarer qu elle peut générer IllegalAccessException ; parce que main() doit avoir un bloc try/catch pour gérer l exception en question.

28 Instruction throw (suite) 1 L exemple correct est : class ThrowsDemo1 { static void proc() throws IllegalAccessException { System.out.println("dans proc()"); throw new IllegalAccessException("demo"); catch(illegalaccessexception e) { System.out.println(e + "attrapee");

29 Lancement l instruction throw unobjetexception permet de lancer une exception unobjetexception doit être une référence vers une instance d une sous-classe de Throwable quand une exception est lancée, 1 l exécution normale du programme est interrompue, 2 la JVM recherche la clause catch la plus proche permettant de traiter l exception lancée, 3 cette recherche se propage au travers des blocs englobants et remonte les appels de méthodes jusqu à ce qu un gestionnaire de l exception soit trouvé, 4 tous les blocs finally rencontrés au cours de cette propagation sont exécutés.

30 Lancement, Exemple : violation d une précondition class ExceptDiv0 extends Exception { public ExceptDiv0(String s) { super(s); public void divise(double x, double y) throws ExceptDiv0 { if (y < 0) throw new ExceptDiv0( Atention!! division par zéro ) return x/y; La divison ne peut être effectuée que si y >= 0 Définition d une nouvelle classe d exception Si la préocondition n est pas vérifiée création et lancement d une exception L exception doit être signalée dans la signature de la méthode

31 Déclaration Toute méthode susceptible de lever une exception normale doit soit l attraper, soit la déclarer explicitement, c est à dire comporter dans sa signature l indication que l exception peut être provoquée : clause throws Les exceptions déclarées dans la clause throws d une méthode sont : les exception levées dans la méthode et non attrapées par celle-ci, les exceptions levées dans des méthodes appelées par la méthode et non attrapées par celle-ci.

32 Déclaration plusieurs classes d exceptions peuvent être indiquées dans la clause throws d une déclaration de méthode Except3 (hérite de) Except2 (hérite de) Except1 (hérite de) Exception Except4 (hérite de) Exception void methodequelconque() throws Except1,Except4 { try { // séquence de code pouvant lever des exceptions de type Except1, Except2, // Except3 ou Except4 catch (Except2 m) { // intercepte les exceptions de type Except2 et Except3 finally { //... Les exceptions de type Except1 et Except4 ne sont pas traitées dans le corps de la méthode, elles doivent être déclarées dans la clause throws

33 Déclaration l obligation de déclaration des exceptions présente un double intérêt ( Programmation Java, J.F. Macary, N. Cédric, Ed. Eyrolles 1996) celui qui écrit une méthode doit être conscient de toutes les exceptions levées par les méthodes qu il appelle. Pour ces exceptions il doit choisir entre les traiter ou les déclarer. Il ne peut les ignorer. celui qui utilise la méthode apprend grâce aux clauses throws quelles sont les exceptions susceptibles d être levées par cette méthode et les méthodes appelées. pour simplifier écriture des programmes (et permettre une extensibilité future) les exceptions standards non pas besoin d être déclarées exceptions définies comme sous classes de Error exceptions définies comme sous classes de RuntimeException (exemple ArrayOutOfBoundException, NullPointerException...)

34 Redéfinition de méthodes public class A { void methodex() throws Except1, Except4 { // séquence de code pouvant // lever des exceptions // de type Except1, // ou Except Lorsque l on redéfinit la méthode peut-on lancer de nouveaux types d exception? Réponse : NON La méthode redéfinie doit respecter le contrat défini par la méthode originale. Elle ne peut rajouter de nouveaux types d exception public Class B extends A {... void methodex() throws Except1, Except4, Except5 ///////// { super.methodex();... // séquence de code pouvant lever une exception de type Except5...

35 Redéfinition de méthodes public Class A { void methodex() throws Except1, Except4 { // séquence de code pouvant // lever des exceptions // de type Except1, // ou Except Mais alors, la méthode redéfinie doit-elle avoir nécessairement la même clause throws? Pas nécessairement public Class B extends A { void methodex() throws Except1, Except4 {... // séquence de code pouvant lever une // exception de type Except3 ou Except4... public Class C extends A { void methodex() { // séquence de code ne levant // pas d exception La méthode redéfinie peut lancer des exceptions spécialisant les exceptions définies dans la clause throws de la méthode originale

36 N ignorez pas les exceptions try{... catch (SomeException e) { //Code très, très suspect Bloc catch vide, détruit la finalité des exceptions qui est de vous obliger à traiter les conditions exceptionnelles qu elles sont supposer représenter. catch (SomeException e) { System.out.println(); e.printstacktrace(); System.exit(0); catch (SomeException e) { // commentaire // justifiant le fait de // ne rien faire

37 En résumé les exceptions rendent la gestion des erreurs plus simple et plus lisible le code pour gérer les erreurs peut être regroupé en un seul endroit : là où on a besoin de traiter l erreur possibilité de se concentrer sur l algorithme plutôt que de s inquiéter à chaque instruction de ce qui peut mal fonctionner, les erreurs remontent la hiérarchie d appels grâce à l exécutif du langage et non plus grâce à la bonne volonté des programmeurs.

38 Conclusion 1 Le code suivant FileInputStream fis; try { fis = new FileInputStream("readme.txt"); catch (FileNotFoundException e) { fis = new FileInputStream("default.txt"); 2 est plus propre que #include <sys/errno.h> int fd; fd = open("readme.txt"); if (fd == -1 && errno == EEXIST) fd = open("default.txt");