EXCEPCIONS ENCADENADES A JAVA

Les excepcions encadenades a Java permeten associar una excepció amb una altra, és a dir, una excepció descriu la causa d'una altra excepció.

Per exemple, considereu una situació en què un mètode llança un Excepció aritmètica a causa d'un intent de dividir per zero.
Però la causa principal de l'error va ser una fallada d'E/S que va provocar que el divisor fos zero.
En aquests casos, les excepcions encadenades ajuden a propagar tant les causes primàries com les subjacents de l'error.

Exemple : L'exemple següent mostra com utilitzar excepcions encadenades a Java.

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  ());      }      }   }

Sortida

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

Nota: Les excepcions encadenades també conegudes com a excepcions imbricades ens permeten associar una causa amb una excepció a Java. Això és útil quan volem propagar informació sobre la causa original d'una excepció.

Constructors

Llançable (causa que es pot llançar) : On causa és l'excepció que provoca l'excepció actual.
Throwable(String msg Throwable cause) : on msg és el missatge d'excepció i causa és l'excepció que provoca l'excepció actual.

Mètodes de llançament de suport a les excepcions encadenades

getCause() : aquest mètode retorna la causa real d'una excepció.
initCause (causa que es pot llançar) : aquest mètode estableix la causa de l'excepció de crida.

Exemple: Ús d'un missatge personalitzat amb excepcions encadenades

A Java podem encadenar excepcions mitjançant el constructor de la classe Throwable.

Java

    // 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  );      }      }   }

Sortida:

Explicació: En aquest exemple, una matriu d'enters i estableix el divisor en 0.

Dins del bloc try, intenta dividir cada element de la matriu per 0, la qual cosa genera una ArithmeticException.
Aquesta ArithmeticException es captura al bloc catch on es crea una nova RuntimeException amb l'excepció original, és a dir, ArithmeticException com a causa.
Atès que no s'atrapa l'Excepció Runtime, que mostra la traça de la pila, incloent l'Exception Runtime i l'Exception Arithmetic.

Avantatges de les excepcions encadenades:

Els avantatges de les excepcions encadenades s'enumeren a continuació:

Aquesta excepció ajuda a la depuració proporcionant detalls tant sobre les causes primàries com les arrels.
Simplifica la gestió d'errors en permetre la propagació del context d'excepció complet.
Això millora la traçabilitat dels errors en aplicacions complexes.

Desavantatges de les excepcions encadenades:

Si no s'utilitza correctament, pot fer que la traça de la pila sigui més llarga i difícil de llegir.
L'ús excessiu pot provocar missatges d'error confusos si les excepcions s'encadenen innecessàriament.
Els desenvolupadors han de garantir que les causes significatives estiguin vinculades; en cas contrari, pot induir a error durant la depuració.

Test suggerit Edita el qüestionari 3 Preguntes

Quin és l'objectiu principal de les excepcions encadenades a Java?