Les exceptions chaînées en Java permettent d'associer une exception à une autre, c'est-à-dire qu'une exception décrit la cause d'une autre exception.

• Par exemple, considérons une situation dans laquelle une méthode lance un ArithmétiqueException à cause d'une tentative de division par zéro.
• Mais la cause première de l’erreur était un échec d’E/S qui faisait que le diviseur était nul.
• Dans de tels cas, les exceptions chaînées contribuent à propager à la fois les causes principales et sous-jacentes de l’erreur.

Exemple : L'exemple suivant montre comment utiliser les exceptions chaînées en Java.

   // Working of chained exceptions   public     class   Geeks     {      public     static     void     main  (  String  []     args  )     {      try     {          // Creating an exception      NumberFormatException     ex     =     new     NumberFormatException  (  'Primary Exception'  );      // Setting the cause of the exception      ex  .  initCause  (  new     NullPointerException  (  'Root cause of the exception'  ));      // Throwing the exception with a cause      throw     ex  ;      }         catch     (  NumberFormatException     ex  )     {          // Displaying the primary exception      System  .  out  .  println  (  'Caught Exception: '     +     ex  );      // Displaying the root cause of the exception      System  .  out  .  println  (  'Cause of Exception: '     +     ex  .  getCause  ());      }      }   }   

Caught Exception: java.lang.NumberFormatException: Primary Exception Cause of Exception: java.lang.NullPointerException: Root cause of the exception  

Note: Les exceptions chaînées, également appelées exceptions imbriquées, nous permettent d'associer une cause à une exception en Java. Ceci est utile lorsque nous souhaitons propager des informations sur la cause initiale d'une exception.

Constructeurs

• Jetable (cause jetable) : Où cause est l'exception qui provoque l'exception actuelle.
• Throwable (String msg Throwable cause) : Où msg est le message d'exception et cause est l'exception qui provoque l'exception actuelle.

Méthodes de prise en charge des exceptions chaînées pouvant être lancées

1. getCause() : Cette méthode renvoie la cause réelle d'une exception.
2. initCause (cause jetable) : Cette méthode définit la cause de l’exception appelante.

Exemple: Utilisation d'un message personnalisé avec des exceptions chaînées

En Java, nous pouvons enchaîner les exceptions en utilisant le constructeur de la classe Throwable.

   // Use a custom message with chained exception   public     class   Geeks     {      public     static     void     main  (  String  []     args  )     {      try     {          // Code that might throw an exception      int  []     n     =     new     int  [  5  ]  ;      int     divisor     =     0  ;      for     (  int     i     =     0  ;     i      <     n  .  length  ;     i  ++  )     {      int     res     =     n  [  i  ]     /     divisor  ;      System  .  out  .  println  (  res  );      }      }         catch     (  ArithmeticException     e  )     {          // Creating a new exception with       // the original as the cause      throw     new     RuntimeException      (  'Error: Division by zero occurred'       e  );      }      }   }   

Sortir:

Explication: Dans cet exemple, un tableau d'entiers et définit le diviseur sur 0.

• À l'intérieur du bloc try, il essaie de diviser chaque élément du tableau par 0, ce qui renvoie une ArithmeticException.
• Cette ArithmeticException est interceptée dans le bloc catch où une nouvelle RuntimeException est créée avec l'exception d'origine, c'est-à-dire ArithmeticException comme cause.
• Étant donné que RuntimeException n'est pas intercepté, ce qui affiche la trace de la pile, y compris RuntimeException et ArithmeticException.

Avantages des exceptions chaînées :

Les avantages des exceptions chaînées sont répertoriés ci-dessous :

• Cette exception facilite le débogage en fournissant des détails sur les causes principales et profondes.
• Il simplifie la gestion des erreurs en permettant la propagation du contexte d'exception complet.
• Cela améliore la traçabilité des erreurs dans les applications complexes.

Inconvénients des exceptions chaînées :

• S'il n'est pas utilisé correctement, cela peut rendre la trace de la pile plus longue et plus difficile à lire.
• Une utilisation excessive peut générer des messages d'erreur déroutants si les exceptions sont enchaînées inutilement.
• Les développeurs doivent s’assurer que les causes significatives sont liées ; sinon cela peut induire en erreur lors du débogage.