Exception

erreur de division

Source de Equation1.java

public class Equation1 { private int a, b; public static void main(String args[]) { int valeurA=Integer.valueOf(args[0]).intValue(); int valeurB=Integer.valueOf(args[1]).intValue(); Equation1 equa = new Equation1(valeurA,valeurB); equa.afficher(); int x = equa.solution(); System.out.println("résultat : X = "+x); } public Equation1(int a, int b) { this.a=a; this.b=b; } public void afficher() { System.out.println(a+" * X = "+b); } int solution() { return b/a; } }

• EXECUTION

  java Equation1 0 2 0 * X = 2 Exception in thread "main" java.lang.ArithmeticException: / by zero at Equation1.solution(Equation1.java:20) at Equation1.main(Equation1.java:10)

• les lignes de la classe :
  • Integer est une classe pour manipuler les entiers comme des objets et non pas uniquement comme une valeur int.
    • Integer.valueOf(chaineDeChiffres) renvoie un objet Integer ayant la valeur correspondante à la chaine de chiffres
    • la méthode intValue() de la classe Integer renvoie la valeur int
  • L'instruction division entière peut lever une exception: ArithmeticException (erreur d'exécution) .
  • Une exception levée (non propagée et non capturée) finit par provoquer l'arrêt de la "méthode du programme principal".
    
• exception :
  • Une exception est un message envoyé lors d'une erreur à l'exécution.
    • Ce message contient des informations sur l'erreur qui s'est produite.
  • JAVA stoppe l'exécution du code là où l'exception a été levée.
    • et envoie le "message" exception
    • sans capture had-hoc du message exception, celui provoque l'arret successif des méthodes appelées jusqu'à la machine JVM qui vous indique l'erreur produite avec beaucoup de détails issus des informations du message.
  • Les exceptions sont organisées en classe.

capturer l'exception

Source de Equation2.java

public class Equation2 { private int a, b; public static void main(String args[]) { int valeurA=Integer.valueOf(args[0]).intValue(); int valeurB=Integer.valueOf(args[1]).intValue(); Equation2 equa = new Equation2(valeurA,valeurB); equa.afficher(); int x = equa.solution(); System.out.println("résultat : X = "+x); } public Equation2(int a, int b) { this.a=a; this.b=b; } public void afficher() { System.out.println(a+" * X = "+b); } int solution() { int x; try { x = b/a; } catch (ArithmeticException e) { x = -1; } return x; } }

• EXECUTION

  java Equation2 0 2 0 * X = 2 résultat : X = -1

• L'instruction "try ... catch" permet de capturer des exceptions :
  • dès qu'une exception est levée dans le corps de try, le traitement de ce corps est terminé
  • catch définit le traitement pour les ArithmeticException capturées.
  • l'exécution continue normalement en reprenant après le bloc try-catch.
  • Ce mécanisme permet de traiter les erreurs et d'empecher qu'elle n'arrete l'application en cours.
• L'exception a été capturée et traitée : x = -1.

propager l'exception

Source de Equation3.java

public class Equation3 { private int a, b; public static void main(String args[]) { int valeurA=Integer.valueOf(args[0]).intValue(); int valeurB=Integer.valueOf(args[1]).intValue(); Equation3 equa = new Equation3(valeurA,valeurB); equa.afficher(); int x = equa.solution(); System.out.println("résultat : X = "+x); } public Equation3(int a, int b) { this.a=a; this.b=b; } public void afficher() { System.out.println(a+" * X = "+b); } int solution() throws ArithmeticException { return b/a; } }

• les lignes de la classe :
  • La déclaration "throws" permet d'indiquer que la méthode est suceptible de lever une exception : içi ArithmeticException, qu'elle ne capture pas par un try-catch
    • ArithmeticException sera propagée/transmise à la méthode appelante si elle est levée.
    • Donc il faut que les méthodes qui appelle la méthode solution
      • mettent éventuellement en place une mécanisme de capture try-cath
      • ou qu'elles propagent elles aussi l'exception.

Source de Prog53.java

public class Prog53 { public static void main(String args[]) { int valeurA=Integer.valueOf(args[0]).intValue(); int valeurB=Integer.valueOf(args[1]).intValue(); Equation3 equa = new Equation3(valeurA,valeurB); equa.afficher(); try { int x = equa.solution(); System.out.println("résultat : X = "+x); } catch (ArithmeticException e) { System.out.println("pas de solution"); } } }

• EXECUTION

  java Prog53 0 2 0 * X = 2 pas de solution

• L'exception ArithmeticException peut survenir dans la méthode solution puisque sa déclaration l'indique (throws)
• Lorsqu'elle survient dans solution, elle est propagée jusqu'à une méthode appelante qui la capture et la traite.C'est la méthode main de Prog53 la capture.

lever une exception

Source de Equation4.java

public class Equation4 { private int a, b; public static void main(String args[]) { int valeurA=Integer.valueOf(args[0]).intValue(); int valeurB=Integer.valueOf(args[1]).intValue(); Equation4 equa = new Equation4(valeurA,valeurB); equa.afficher(); int x = equa.solution(); System.out.println("résultat : X = "+x); } public Equation4(int a, int b) { this.a=a; this.b=b; } public void afficher() { System.out.println(a+" * X = "+b); } int solution() throws ArithmeticException { if (a==0) throw new ArithmeticException( "division entière par zéro"); else return b/a; } }

• les lignes de la classe :
  • L'instruction "throw" (sans s) permet de générer/lever une exception, içi ArithmeticException.
    • De plus, un message d'erreur est ajoutée dans les informations véhiculées par l'exception.
    • l'instruction throw instancie un objet exception, arrête l'exécution normale des instructions et sauf try-catch propage l'exception.

Source de Prog54.java

public class Prog54 { public static void main(String args[]) { int valeurA=Integer.valueOf(args[0]).intValue(); int valeurB=Integer.valueOf(args[1]).intValue(); Equation4 equa = new Equation4(valeurA,valeurB); equa.afficher(); try { int x = equa.solution(); System.out.println("résultat : X = "+x); } catch (ArithmeticException e) { System.out.println(e.getMessage()); } } }

• EXECUTION

  java Prog54 0 2 0 * X = 2 division entière par zéro

• A la capture d'exception, il est possible d'afficher le message associé en utilisant la méthode getMessage sur l'objet exception.
  • getMessage est une des méthodes de l'objet Exception qui donne des informations sur l'exception.

classe Exception

• L'exécution de certaines instructions ou méthodes peuvent lever des (erreurs d'exécution) exceptions. Celles-çi sont organisées en classe, par exemple, la classe RuntimeException regroupe les incidents du genre :
  • division par 0 (ArithmeticException),
  • en dehors des bornes d'un tableau (IndexoutOfBoundsException),
  • méthode appliquée à une référence nulle (NullPointerException),
  • ...
• try ... catch, capture d'exception :
  • try { bloc d'instructions
      pouvant lever des exceptions
} catch { type_d_exception e) {
     traitement de e
} catch {autre_type_d_exception e) {
     traitement de e
}
  • dès qu'une exception est levée dans le corps de try, le traitement de ce corps est terminé et catch définit le traitement de l'exception capturée.
• throws, décaler/propager une exception :
  • [<modificateur>] <type> <nomMéthode> ([<paramètres>]) throws <liste d'exceptions> { <corps de la méthode pouvant lever des exceptions> }
  • les exceptions listées sont propagées/transmises à la méthode appelante si elles sont levées dansle corps de la méthode traitée.
  • Donc une exception peut être propagée jusqu'à une méthode appelante qui la capture et la traite.
• Il n'est pas nécessaire de "truffer" son programme Java de capture d'exceptions. Toutes les exceptions ne sont pas obligatoirement à traiter (capturer par try-catch ou propager par throws).
  • Il n'est pas obligatoire de capturer ou propager les exceptions (unchecked) non contrôlées : les Error et RunTimeException. Mais une exception levée non propagée et non capturée finit par provoquer l'arrêt de la "méthode du programme principal".
  • Les Exceptions de la classe des IOException doivent être obligatoirement capturées ou propagées.
• Il est possible de créer des nouvelles sous-classes d'Exception et de générer/lever de telles exceptions par l'instruction throw.

exercices

• Ecrire une classe MaDate6 comme la classe MaDate5 qui gère les exceptions
  • dans le constructeur si la date est invalide
  • si demain n'existe pas (fin du monde en 9999)
    Correction
  • voici un programme de test Prog126.java
    • Ecrire le même, en plus robuste,pour la nouvelle classe MaDate6
    • Correction
• quel CLASSPATH pour l'exécuter ?Reprenons la gestion d'une bibliothèque de livres.
  • Dans la classe Bibliotheque2, supprimer un livre à une position erronée ne provoque ni message ni erreur.
  • Pourtant la méthode removeElementAt de Vector lève une exception ArrayIndexOutOfBoundsException si la position est erronée
  • Nous suggèrons de lever l'exception dans la classe bibliothèque et de la capturer dans le programme de gestion pour afficher un message clair à l'utilisateur.
    CorrectionProgramme   CorrectionBibliotheque