Las excepciones encadenadas en Java permiten asociar una excepción con otra, es decir, una excepción describe la causa de otra excepción.

• Por ejemplo, considere una situación en la que un método arroja un Excepción aritmética debido a un intento de dividir por cero.
• Pero la causa principal del error fue una falla de E/S que provocó que el divisor fuera cero.
• En tales casos, las excepciones encadenadas ayudan a propagar las causas primarias y subyacentes del error.

Ejemplo : El siguiente ejemplo demuestra cómo utilizar excepciones encadenadas 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 

Nota: Las excepciones encadenadas, también conocidas como excepciones anidadas, nos permiten asociar una causa con una excepción en Java. Esto es útil cuando queremos propagar información sobre la causa original de una excepción.

Constructores

• Lanzable(Causa arrojable) : Donde causa es la excepción que causa la excepción actual.
• Throwable (mensaje de cadena causa Throwable) : Donde msg es el mensaje de excepción y causa es la excepción que causa la excepción actual.

Métodos de excepciones encadenadas de soporte arrojable

1. obtener causa() : este método devuelve la causa real de una excepción.
2. initCause(Causa arrojable) : este método establece la causa de la excepción de llamada.

Ejemplo: Usar un mensaje personalizado con excepciones encadenadas

En Java podemos encadenar excepciones usando el constructor de la clase 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);  }  } } 

Producción:

¿Qué es el envío de directorio?

Explicación: En este ejemplo, se crea una matriz de números enteros y se establece el divisor en 0.

• Dentro del bloque try intenta dividir cada elemento de la matriz por 0, lo que genera una excepción ArithmeticException.
• Esta ArithmeticException queda atrapada en el bloque catch donde se crea una nueva RuntimeException con la excepción original, es decir, ArithmeticException como causa.
• Dado que RuntimeException no se detecta, se muestra el seguimiento de la pila, incluidas RuntimeException y ArithmeticException.

Ventajas de las excepciones encadenadas:

Las ventajas de las excepciones encadenadas se enumeran a continuación:

• Esta excepción ayuda en la depuración al proporcionar detalles sobre las causas primarias y raíz.
• Simplifica el manejo de errores al permitir la propagación del contexto de excepción completo.
• Esto mejora la trazabilidad de los errores en aplicaciones complejas.

Desventajas de las excepciones encadenadas:

• Si no se usa correctamente, puede hacer que el seguimiento de la pila sea más largo y difícil de leer.
• El uso excesivo puede generar mensajes de error confusos si las excepciones se encadenan innecesariamente.
• Los desarrolladores deben garantizar que las causas significativas estén vinculadas; de lo contrario, puede inducir a error durante la depuración.