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.

// 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 

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

1. getCause() : aquest mètode retorna la causa real d'una excepció.
2. 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.

// 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:

quins mesos hi ha al q3

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 d'assegurar-se que les causes significatives estan vinculades; en cas contrari, pot induir a error durant la depuració.