Java - Chained Exceptions

In Java, exceptions occur when the normal flow of the program is disrupted, causing the program to stop. Chained exceptions help relate one exception to another, where one exception is considered the cause of another.

Understanding Chained Exceptions

Chained exceptions are associated such that the previous exception causes each exception in the chain. Chained exception helps us to debug errors and find the root cause of the errors.

For Example

Consider a situation in a Banking System where a user tries to transfer money. When the user logs in, the user logs in successfully, but the transaction database connection fails, which then throws an SQLException.

Here, the transferMoney() method hides the SQLException because it is low-level. Then, it wraps that SQLException into a custom exception called TransactionFailedException.

The SQLException is the root cause, and the TransactionFailedException is the chained exception for the SQLException.

Supported by Throwable Class

In Java, the Throwable class provides constructors and methods to support chained exceptions.

Constructors

The following are the two constructors supported by the Throwable Class −

• Throwable(Throwable cause) − The cause is the current exception.
  
• Throwable(String msg, Throwable cause) − The msg is the exception message, and the cause is the current exception.

Methods

The following are the two methods supported by the Throwable Class −

• getCause() − This method returns the actual cause.
  
• initCause() − This method sets the cause for calling an exception.

Example 1

In the following example, we are causing an ArithmeticException in the test method, and then we are wrapping the ArithmeticException inside a custom exception, ApplicationException, and throwing it. This demonstrates the Chained Exceptions in Java −

public class Tester {
    public static void main(String[] args) {
        try {
            test();
        } catch (ApplicationException e) {
            e.printStackTrace();
        }
    }
    public static void test() throws ApplicationException {
        try {
            int a = 0;
            int b = 1;
            System.out.println(b / a);
        } catch (Exception e) {
            throw new ApplicationException("Chained Exception",e);
        }
    }
}

class ApplicationException extends Exception {
    public ApplicationException(String message, Exception cause) {
        super(message, cause);
    }
}

Output

ApplicationException: Chained Exception
	at Tester.test(Tester.java:15)
	at Tester.main(Tester.java:4)
Caused by: java.lang.ArithmeticException: / by zero
	at Tester.test(Tester.java:13)
	... 1 more

Example 2

In the following example, we are causing a NullPointerException in the test method, and then we are wrapping the NullPointerException inside a custom exception, DemoException, and throwing it. This demonstrates the Chained Exceptions in Java −

public class Tester {
    public static void main(String[] args) {
        try {
            test();
        } catch (DemoException e) {
            e.printStackTrace();
        }
    }
    public static void test() throws DemoException {
        try {
            String str = null;
            System.out.println(str.length());
        } catch (Exception e) {
            throw new DemoException("Chained Exception", e);
        }
    }
}

class DemoException extends Exception {
    public DemoException(String message, Exception cause) {
        super(message, cause);
    }
}

Output

DemoException: Chained Exception
	at Tester.test(Tester.java:14)
	at Tester.main(Tester.java:4)
Caused by: java.lang.NullPointerException: Cannot invoke 
"String.length()" because "<local0>" is null
	at Tester.test(Tester.java:12)
	... 1 more