Exception guidelines

Recommandations pour les exceptions

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.)

Summary

Résumé

Exercises

Exercices

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
   there.
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
   exception.
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
   clause.
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
   exception.
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
   exceptions.
7. Write
   code to generate and catch an
   ArrayIndexOutOfBoundsException.
8. Create
   your own resumption-like behavior using a while loop that repeats until
   an exception is no longer
   thrown.
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
   method.
10. Demonstrate
    that a derived-class constructor cannot catch exceptions thrown by its
    base-class
    constructor.
11. Show
    that OnOffSwitch.java can fail by throwing a RuntimeException
    inside the try
    block.
12. Show that
    WithFinally.java doesn’t fail by throwing a RuntimeException
    inside the try
    block.
13. Modify
    Exercise 6 by adding a finally clause. Verify your finally clause
    is executed, even if a NullPointerException is
    thrown.
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
    “Constructors.”
15. Modify
    StormyInning.java by adding an UmpireArgument exception type, and
    methods that throw this exception. Test the modified
    hierarchy.
16. Remove
    the first catch clause in Human.java and verify that the code still
    compiles and runs
    properly.
17. Add a
    second level of exception loss to LostMessage.java so that the
    HoHumException is itself replaced by a third
    exception.
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
    RuntimeException.
19. Add
    an appropriate set of exceptions to
    c08:GreenhouseControls.java.

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.