t t 10) Gestion des erreurs avec les exceptions
10) Gestion des erreurs avec les exceptions
Texte original t Traducteur : N. CULWELL-KANAREK, Anthony PRAUD, A. FORTUN
Ce chapitre contient 3 pages
1 2 3
t t t
t t t

Exception guidelines


Recommandations pour les exceptions

t t t
Use exceptions to: t Utilisez les exceptions pour :
t t t
  1. Fix the problem and call the method that caused the exception again.
  2. Patch things up and continue without retrying the method.
  3. Calculate some alternative result instead of what the method was supposed to produce.
  4. Do whatever you can in the current context and rethrow the same exception to a higher context.
  5. Do whatever you can in the current context and throw a different exception to a higher context.
  6. Terminate the program.
  7. Simplify. (If your exception scheme makes things more complicated, then it is painful and annoying to use.)
  8. Make your library and program safer. (This is a short-term investment for debugging, and a long-term investment (for application robustness.)
  1. Fixer le problème et appeler la méthode causant cette exception une nouvelle fois.
  2. Corriger les choses et continuez sans ré-essayer la méthode.
  3. Calculer quelques résultats alternatif à la place de ce que devrait produire la méthode.
  4. Faire ce que vous désirez dans le contexte courant et relancer la même exception dans un contexte plus haut.
  5. Faire ce que vous désirez dans le contexte courant et lancer une exception différente dans un contexte plus haut.
  6. Terminer le programme.
  7. Simplifier. (Si votre schéma d'exceptions rend les choses plus compliqués, alors il est douloureux et ennuyer à utiliser.)
  8. Rendre votre librairie et programme plus sûr. (C'est un investissement à court-terme pour le déboguage, et un investissement à long-terme pour la robustesse de l'application.)
t t t




t t t
Improved error recovery is one of the most powerful ways that you can increase the robustness of your code. Error recovery is a fundamental concern for every program you write, but it’s especially important in Java, where one of the primary goals is to create program components for others to use. To create a robust system, each component must be robust. t La recherche amélioré d'erreur "Index1127">est l'une des puissantes voies qui peut augmenter la robustesse de votre code. La recherche d'erreur est une préoccupation fondamentale pour chaque programme que vous écrivez, mais c'est surtout important en Java, où l'un des buts primaire est de crée des composants de programme pour d'autre utilisations. Pour créer un système robuste, chaque composant doit être robuste.
t t t
The goals for exception handling in Java are to simplify the creation of large, reliable programs using less code than currently possible, and with more confidence that your application doesn’t have an unhandled error. t Les buts de l'identification d'exception en Java sont de simplifier la création de programmes larges, reliables en utilisant le moins de code possible, et avec plus d'assurance que votre application n'ai pas d'erreur non identifiée.
t t t
Exceptions are not terribly difficult to learn, and are one of those features that provide immediate and significant benefits to your project. Fortunately, Java enforces all aspects of exceptions so it’s guaranteed that they will be used consistently by both library designers and client programmers.

Les exceptions ne sont pas terriblement difficile à apprendre, et sont l'une des chose qui procurent des bénéfices immédiat à votre projet. Heureusement, Java impose tous les aspects des exceptions donc cela garantie qu'elle seront employés uniformément par à la fois les concepteurs de librairies et les programmeurs clients.

t t t




t t t
Solutions to selected exercises
can be found in the electronic document The Thinking in Java Annotated
Solution Guide
, available for a small fee from

t Les solutions aux exercices sélectionnées peuvent être trouvés dans le document électronique The Thinking in Java Annotated Solution Guide,, disponible pour une modique somme à www.BruceEckel.com.
t t t
  1. Create a class with a
    main( ) that throws an object of class Exception inside a
    try block. Give the constructor for Exception a String
    argument. Catch the exception inside a catch clause and print the
    String argument. Add a finally clause and print a message to prove
    you were
  2. Create your
    own exception class using the extends keyword. Write a constructor for
    this class that takes a String argument and stores it inside the object
    with a String reference. Write a method that prints out the stored
    String. Create a try-catch clause to exercise your new
  3. Write a
    class with a method that throws an exception of the type created in Exercise 2.
    Try compiling it without an exception specification to see what the compiler
    says. Add the appropriate exception specification. Try out your class and its
    exception inside a try-catch
  4. Define an
    object reference and initialize it to null. Try to call a method through
    this reference. Now wrap the code in a try-catch clause to catch the
  5. Create a
    class with two methods, f( ) and g( ). In
    g( ), throw an exception of a new type that you define. In
    f( ), call g( ), catch its exception and, in the
    catch clause, throw a different exception (of a second type that you
    define). Test your code in
    main( ).
  6. Create
    three new types of exceptions. Write a class with a method that throws all
    three. In main( ), call the method but only use a single
    catch clause that will catch all three types of
  7. Write
    code to generate and catch an
  8. Create
    your own resumption-like behavior using a while loop that repeats until
    an exception is no longer
  9. Create a
    three-level hierarchy of exceptions. Now create a base-class A with a
    method that throws an exception at the base of your hierarchy. Inherit B
    from A and override the method so it throws an exception at level two of
    your hierarchy. Repeat by inheriting class C from B. In
    main( ), create a C and upcast it to A, then call the
  10. Demonstrate
    that a derived-class constructor cannot catch exceptions thrown by its
  11. Show
    that OnOffSwitch.java can fail by throwing a RuntimeException
    inside the try
  12. Show that
    WithFinally.java doesn’t fail by throwing a RuntimeException
    inside the try
  13. Modify
    Exercise 6 by adding a finally clause. Verify your finally clause
    is executed, even if a NullPointerException is
  14. Create an
    example where you use a flag to control whether cleanup code is called, as
    described in the second paragraph after the heading
  15. Modify
    StormyInning.java by adding an UmpireArgument exception type, and
    methods that throw this exception. Test the modified
  16. Remove
    the first catch clause in Human.java and verify that the code still
    compiles and runs
  17. Add a
    second level of exception loss to LostMessage.java so that the
    HoHumException is itself replaced by a third
  18. In
    Chapter 5, find the two programs called Assert.java and modify these to
    throw their own type of exception instead of printing to System.err. This
    exception should be an inner class that extends
  19. Add
    an appropriate set of exceptions to

  1. Créez une classe avec un main() qui lance un objet de la classe Exception dans un bloc try. Donnez au constructeur d'Exception un argument de type String. Piégez l'exception dans une cause catch et affichez l'argument du String. Ajoutez une cause finally et affichez un message pour prouver que vous vous situez là.
  2. Créez votre propre classe d'exception utilisant le mot-clé extends. Écrivez un constructeur pour cette classe qui prendra un argument de type String et stockez le dedans l'objet par une référence au String. Écrivez une méthode qui imprime en sortie le String stocké. Créez une cause try-catch pour exercer votre nouvelle exception.
  3. Écrivez une classe avec une méthode qui lance une exception du type de celle crée dans l'exercice 2. Éssayez de le compiler sans spécification d'exception afin de voir ce que dit le compilateur. Ajoutez la spécification d'exception adéquate. Essayez en sortie votre classe et son exception dans une cause try-catch.
  4. Définissez une référence objet et initialisez la à null. Essayez d'appeler cette méthode grâce à cette référence. Maintenant enveloppez le code dans une clause try-catch afin de capter l'exception.
  5. Créez une classe ayant deux méthodes, f() et g( ). Dans g(), lancez une exception d'un nouveau type que vous définirez. Dans f(), captez son exception et, dans la clause catch, lancez une exception différente (d'un second type que vous définirez). Testez votre code dans main( ).
  6. Créez trois nouveaux types d'exceptions. Écrivez une classe avec une méthode qui lance les trois. Dans main(), appelez la méthode mais en utilisant seulement une seule clause catch qui piégera les trois types d'exceptions.
  7. Écrivez un code pour générer et capter une ArrayIndexOutOfBoundsException.
  8. Créez votre propre comportement de type-résurrection en utilisant une boucle while qui se répète tant qu'une exception n'est pas lancée.
  9. Créez une hiérarchie à trois niveaux d'exceptions. Maintenant créez un classe-de-base A avec une méthode qui lance une exception à la base de votre hiérarchie. Héritez B depuis A et outrepassez la méthode afin qu'elle lance une exception au second niveau de votre hiérarchie. Répétez en faisant hériter la classe C de la classe B. Dans main(), créez un C et sur-typez le en A, puis appelez la méthode.
  10. Démontrez qu'un constructeur d'une classe-dérivé ne peut pas capter les exceptions lancées par son constructeur de sa classe-de-base.
  11. Montrez que OnOffSwitch.java peut échouer en lançant une RuntimeException dans le bloc try.
  12. Montrez que WithFinally.java n'échoue pas en lançant une RuntimeException dans le bloc try.
  13. Modifiez l'Exercice 6 en ajoutant une clause finally. Vérifiez que votre clause finally est exécutée, même si une NullPointerException est lancée.
  14. Créez un exemple où vous utiliserez un drapeau pour contrôler si le nettoyage du code est appelé, comme décrit dans le second paragraphe après l'en-tête « Constructors ».
  15. Modifiez StormyInning.java en ajoutant une exception de type UmpireArgument, et de les méthodes qui lancent cette exception. Testez la hiérarchie modifiée.
  16. Enlevez la première cause d'identification (catch) dans Human.java et vérifiez que le code compile et s'exécute toujours.
  17. Ajoutez un second niveau de perte d'exception à LostMessage.java afin que HoHumException soit lui-même remplacé par une troisième exception.
  18. Dans le Chapitre 5, trouvez deux programmes appelés Assert.java et modifiez les pour lancer leur propres types d'exception au lieu d'imprimer vers System.err. Cette exception doit être une classe interne qui étends RuntimeException.
  19. Ajoute un jeu d'exceptions appropriés à c08:GreenhouseControls.java.
t t t
The C programmer can look up the return value of printf( ) for an
example of this.
t [51]Le programmeur C peut regarder la valeur renvoyée par printf() en exemple à ceci.
t t t
This is a significant improvement over C++ exception handling, which
doesn’t catch violations of exception specifications until run time, when
it’s not very useful.
t [52] "2">C'est une amélioration significative sur la gestion d'exception de C++, qui ne piège pas les violations des spécifications d'exceptions avant l'exécution, quand ce n'est pas très utile.
t t t
C++ exception handling does not have the finally clause because it relies
on destructors to accomplish this sort of cleanup.
t [53]La gestion d'exception de C++ n'a pas de cause finally parcqu'elle est reliée au destructeur pour accomplir ce type de nettoyage.
t t t
A destructor is a function that’s always called when an object becomes
unused. You always know exactly where and when the destructor gets called. C++
has automatic destructor calls, but Delphi’s Object Pascal versions 1 and
2 do not (which changes the meaning and use of the concept of a destructor for
that language).
t [54]Un destructeur est une fonction qui est toujours appelé quand un objet devient inutilisé. Vous savez toujours exactement où et quand le constructeur est appelé. C++ possède des appels automatique au destructeur, mais le Pascal Objet de Delphi dans ces versions 1 et 2 n'en a pas (ce qui change la pensée et l'usage du concept d'un destructeur pour ce langage).<
t t t
ISO C++ added similar constraints that require derived-method exceptions to be
the same as, or derived from, the exceptions thrown by the base-class method.
This is one case in which C++ is actually able to check exception specifications
at compile-time.
t [55]ISO C++ a ajouté des contraintes similaires qui nécessitent que les exceptions dérivées-de-méthode soient les même que, ou dérivées des, exceptions lancées par la méthode de la classe-de-base. C'est un cas dans lequel C++ est actuellement capable de rechercher des spécifications d'exception au moment de la compilation.
t t t
In C++, a destructor would handle this for you.

     [ Previous Chapter ]
    [ Short TOC ]
    [ Table of Contents ]
    [ Index ]
     [ Next Chapter ]
Last Update:04/24/2000
t [56]En C++, un destructeur pourrait gérer cela pour vous.
t t t
t t t
t t
t t t
Sommaire Le site de Bruce Eckel