Relancer une exception en Java | Gestion des exceptions

Feb 23 2023

Une exception interceptée dans le bloc try peut être levée à nouveau et peut être gérée. Le bloc try juste au-dessus de l'instruction rethrow interceptera l'objet rethrow.

Une exception interceptée dans le bloc try peut être levée à nouveau et peut être gérée. Le bloc try juste au-dessus de l'instruction rethrow interceptera l'objet rethrow. S'il n'y a pas de bloc try juste au-dessus de l'instruction rethrow, la méthode contenant l'instruction rethrow la gère. Pour propager une exception, le bloc catch peut choisir de relancer l'exception à l'aide de l' instruction throw . Notez qu'il n'y a pas de syntaxe spéciale pour relancer.

· Exemple d'exemple : relancer une exception
· Programme
· Mettre à jour la trace de la pile avant de relancer
· Relancer une nouvelle exception

Exemple d'exemple : relancer une exception

Puisque vous avez déjà la référence à l'exception actuelle, vous pouvez simplement renvoyer cette référence :

catch(Exception e) { 
System.out.println("An exception was thrown"); 
throw e; 
}

Le fait de relancer une exception la fait passer aux gestionnaires d'exceptions dans le contexte supérieur suivant. Toutes les autres clauses catch pour le même bloc try sont toujours ignorées. De plus, tout ce qui concerne l'objet d'exception est préservé, de sorte que le gestionnaire du contexte supérieur qui intercepte le type d'exception spécifique peut extraire toutes les informations de cet objet. Si le gestionnaire n'existe pas, cette action entraînera la transmission de l'exception à la méthode appelante. Si l'opération de relance se produit dans la méthode principale , l'exception est transmise à la JVM et affichée sur la console.

Le but de l'opération de relance est d'attirer l'attention du monde extérieur sur le fait qu'une exception s'est produite et en même temps d'exécuter toute logique de contingence (telle que la journalisation) dans le bloc catch .

Programme

public class Main {
 
   public int test(int n1, int n2) {
     try{
           return n1/n2;
      }catch(ArithmeticException e){
         throw e; 
      }
   }
 
   public static void main(String[] args) {
      Main main = new Main();
      try{
          System.out.println(main.test(30, 0));
      }catch(Exception e){
          e.printStackTrace();
      }
   }
 
}

java.lang.ArithmeticException: / by zero
        at Main.test(Main.java:5)
        at Main.main(Main.java:14)

Si vous relevez simplement l'exception actuelle, les informations que vous imprimez à propos de cette exception dans printStackTrace() se rapporteront à l'origine de l'exception, pas à l'endroit où vous la relevez. Si vous souhaitez installer de nouvelles informations de trace de pile, vous pouvez le faire en appelant fillInStackTrace() , qui renvoie un objet Throwable qu'il crée en remplissant les informations de pile actuelles dans l'ancien objet d'exception. Voici à quoi ça ressemble :

//: exceptions/Rethrowing.java 
// Demonstrating fillInStackTrace() 
public class Rethrowing { 
 public static void f() throws Exception { 
 System.out.println("originating the exception in f()"); 
 throw new Exception("thrown from f()"); 
 } 
 public static void g() throws Exception { 
 try { 
   f(); 
 } catch(Exception e) { 
   System.out.println("Inside g(),e.printStackTrace()"); 
   e.printStackTrace(System.out); 
   throw e; 
 } 
 } 
 public static void h() throws Exception {
  try { 
   f(); 
 } catch(Exception e) { 
   System.out.println("Inside h(),e.printStackTrace()"); 
   e.printStackTrace(System.out); 
   throw (Exception)e.fillInStackTrace(); 
 } 
 } 
 public static void main(String[] args) { 
 try { 
     g(); 
 } catch(Exception e) { 
     System.out.println("main: printStackTrace()"); 
     e.printStackTrace(System.out); 
 } 
 try { 
     h(); 
 } catch(Exception e) { 
     System.out.println("main: printStackTrace()"); 
     e.printStackTrace(System.out); 
 } 
 } 
}

originating the exception in f() 
Inside g(),e.printStackTrace() 
java.lang.Exception: thrown from f() 
     at Rethrowing.f(Rethrowing.java:7) 
     at Rethrowing.g(Rethrowing.java:11) 
     at Rethrowing.main(Rethrowing.java:29) 
main: printStackTrace() 
java.lang.Exception: thrown from f() 
     at Rethrowing.f(Rethrowing.java:7) 
     at Rethrowing.g(Rethrowing.java:11) 
     at Rethrowing.main(Rethrowing.java:29) 
originating the exception in f() 
Inside h(),e.printStackTrace() 
java.lang.Exception: thrown from f() 
     at Rethrowing.f(Rethrowing.java:7) 
     at Rethrowing.h(Rethrowing.java:20) 
     at Rethrowing.main(Rethrowing.java:35) 
main: printStackTrace() 
java.lang.Exception: thrown from f() 
     at Rethrowing.h(Rethrowing.java:24) 
     at Rethrowing.main(Rethrowing.java:35) 
*///:~

Relancer une nouvelle exception

Il est également possible de relancer une exception différente de celle que vous avez attrapée. Si vous faites cela, vous obtenez un effet similaire à celui obtenu lorsque vous utilisez fillInStackTrace() — les informations sur le site d'origine de l'exception sont perdues et il ne vous reste que les informations relatives au nouveau lancement :

//: exceptions/RethrowNew.java 
// Rethrow a different object from the one that was caught. 
class OneException extends Exception { 
 public OneException(String s) { super(s); } 
} 
class TwoException extends Exception {
 public TwoException(String s) { super(s); } 
} 
public class RethrowNew { 
 public static void f() throws OneException { 
 System.out.println("originating the exception in f()"); 
 throw new OneException("thrown from f()"); 
 } 
 public static void main(String[] args) { 
 try { 
 try { 
   f(); 
 } catch(OneException e) { 
   System.out.println( 
   "Caught in inner try, e.printStackTrace()"); 
   e.printStackTrace(System.out); 
   throw new TwoException("from inner try"); 
 } 
 } catch(TwoException e) { 
   System.out.println( 
   "Caught in outer try, e.printStackTrace()"); 
   e.printStackTrace(System.out); 
 } 
 } 
}

originating the exception in f() 
Caught in inner try, e.printStackTrace() 
OneException: thrown from f() 
   at RethrowNew.f(RethrowNew.java:15) 
   at RethrowNew.main(RethrowNew.java:20) 
Caught in outer try, e.printStackTrace() 
TwoException: from inner try 
   at RethrowNew.main(RethrowNew.java:25) 
*///:~

Vous n'avez jamais à vous soucier de nettoyer l'exception précédente, ou toute exception d'ailleurs. Ce sont tous des objets basés sur le tas créés avec new, donc le ramasse-miettes les nettoie automatiquement.

Souvent, les lecteurs novices peuvent être confus quant à l'utilisation des trois mots-clés : throw , throws et Throwable . Il est donc utile de s'attarder sur les trois concepts ensemble afin d'en préciser le sens.

Jetable est une classe. Bien que la classe Throwable soit dérivée de la classe java.lang.Object de la bibliothèque de classes Java, Throwable est la super-classe de toutes les classes qui gèrent les exceptions.

Le mot clé throw est une instruction qui lève une exception. Notez qu'une exception peut être levée soit par l'instruction throw, soit lorsqu'une erreur se produit lors de l'exécution de toute autre instruction.

Le mot clé throws est une clause spécifiée dans la définition de la méthode qui indique que la méthode lève les exceptions mentionnées après le mot clé throws, qui sont gérées dans les méthodes appelées.