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:

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.

¿Cuál es el objetivo principal de las excepciones encadenadas en Java?

• A

  Para ocultar la causa raíz de una excepción

• B

  Para asociar una excepción con otra

• do

  Para mejorar el rendimiento del código

• D

  Para corregir automáticamente errores de tiempo de ejecución

Las excepciones encadenadas permiten vincular una excepción con otra para mostrar la causa raíz.

¿Qué método se utiliza para establecer la causa de una excepción?

• A

  obtener mensaje()

• B

  establecerExcepción()

• do

  causainicial()

• D

  causainicial()

El método initCause() establece la causa subyacente de una excepción.

En el ejemplo, ¿qué tipo de excepción se establece como causa de NumberFormatException?

• A

  IOExcepción

• B

  Excepción aritmética

• do

  Excepción de puntero nulo

• D

  Excepción de tiempo de ejecución

El ejemplo establece una NullPointerException como causa de NumberFormatException.