Chained Exceptions in Java

Chained Exceptions in Java allow associating one exception with another, i.e. one exception describes the cause of another exception.

• For example, consider a situation in which a method throws an ArithmeticException because of an attempt to divide by zero.
• But the root cause of the error was an I/O failure that caused the divisor to be zero.
• In such cases, chained exceptions help propagate both the primary and underlying causes of the error.

Example: The following example demonstrates how to use chained exceptions in 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: Chained exceptions, also known as nested exceptions, allow us to associate a cause with an exception in Java. This is useful when we want to propagate information about the original cause of an exception.

Constructors

• Throwable(Throwable cause): Where cause is the exception that causes the current exception.
• Throwable(String msg, Throwable cause): Where msg is the exception message and cause is the exception that causes the current exception.

Methods of Throwable Supporting Chained Exceptions

1. getCause(): This method returns actual cause of an exception.
2. initCause(Throwable cause): This method sets the cause for the calling exception.

Example: Using a Custom Message with Chained Exceptions

In Java, we can chain exceptions using the constructor of the Throwable class.

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

Output:

Explanation: In this example, an array of integers and sets the divisor to 0.

• Inside the try block, it try to divide each element of the array by 0, which throws an ArithmeticException.
• This ArithmeticException is caught in the catch block, where a new RuntimeException is created with the original exception i.e. ArithmeticException as its cause.
• Since the RuntimeException is not caught, which displays the stack trace, including the RuntimeException and the ArithmeticException.

Advantages of Chained Exceptions:

The advantages of chained exceptions are listed below:

• This exception helps in debugging by providing details about both primary and root causes.
• It simplifies error handling by enabling propagation of complete exception context.
• This improves traceability of errors in complex applications.

Disadvantages of Chained Exceptions:

• If not used properly, it can make the stack trace longer and harder to read.
• Overuse may cause confusing error messages if exceptions are chained unnecessarily.
• Developers must ensure meaningful causes are linked; otherwise, it can mislead during debugging.