Chained Exceptions in Java

In Java, a chained exception is a technique that enables programmers to associate one Exception with another. By providing additional information about a specific exception, debugging can be made easier. A chained exception is created by wrapping an existing exception in a new exception, which becomes the root cause of the new Exception.

The new Exception can provide additional information, while the original Exception contains the actual error message and stack trace. It makes it easier to determine and fix the problem's source. Chained exceptions are especially useful when an exception is thrown due to another exception.

In Java, a chained exception is created using one of the constructors of the exception class.

Throwable Class

Constructors and methods for supporting chained exceptions are available in the Throwable class. Let's start by taking a look at the constructors.

Throwable(Throwable cause): A Java constructor creates a new exception object with a specified cause exception.

Throwable(String desc, Throwable cause): A Java constructor creates a new Throwable object with a message and a cause. It allows for chaining exceptions and providing more detailed information about errors.

In Java, the following Throwable class methods enable chained exceptions:

getCause(): It is a Java method of the Throwable class that returns the cause of the current Exception. It allows for accessing the Exception or error that triggered the current Exception to be thrown.

initCause() method: determines the reason for the calling Exception.

Example of Chained Exception:

Filename: ChainedExceptionExample.java

public class ChainedExceptionExample {
    public static void main(String[] args) {
        try {
            String s = null;
            int num = Integer.parseInt(s); // the line will throw a NumberFormatException
        } catch (NumberFormatException e) {
            // create a new RuntimeException with the message "Exception."
            RuntimeException ex = new RuntimeException("Exception");
            // set the cause of the new Exception to a new NullPointerException with the message " It is actual cause of the exception "
            ex.initCause(new NullPointerException("It is actual cause of the exception"));
            // throw the new Exception with the chained Exception
            throw ex;
        }
    }
}

Output:

Exception in thread "main" java.lang.RuntimeException: Exception at ChainedExceptionExample.main(ChainedExceptionExample.java:7)
Caused by: Java.lang.NullPointerException: It is actual cause of the exception at ChainedExceptionExample.main(ChainedExceptionExample.java:8)

Example of with and without chained Exception

Without Chained Exception:

Filename: NonChainedExceptionExample.java

// Importing the Scanner class from Java.util package
import java.util.Scanner;

// Creating a public class named NonChainedExceptionExample
public class NonChainedExceptionExample {

// Defining the main method that will be executed when the program runs
public static void main(String[] args) {
    
    // Creating a new Scanner object to read input from the console
    Scanner scanner = new Scanner(System.in);
    
    // Asking the user to enter a positive integer
    System.out.print("Enter a positive integer: ");
    
    // Reading the input integer from the user
    int num = scanner.nextInt();
    
    // Closing the scanner object to free up resources
    scanner.close();
    
    try {
        // Checking if the input integer is negative and throwing an IllegalArgumentException if it is
        if (num < 0) {
            throw new IllegalArgumentException("Number must be positive");
        }
        
        // Dividing 100 by the input integer and storing the result in the variable result
        int result = 100 / num;
        
        // Printing the result to the console
        System.out.println("Result: " + result);
    } catch (IllegalArgumentException e) {
        // Catching the IllegalArgumentException and printing an error message with the Exception's message
        System.out.println("Invalid input: " + e.getMessage());
    } catch (ArithmeticException e) {
        // Catching the ArithmeticException and printing an error message for division by zero
        System.out.println("Error: division by zero");
    }
  }
}

Output:

Enter a positive integer: -9
Invalid input: Number must be positive

With Chained Exception:

Filename: ChainedExceptionExample.java

// import the Scanner class to allow user input
import java.util.Scanner;

public class ChainedExceptionExample {
    public static void main(String[] args) {
// create a new Scanner object to read user input from the console
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a positive integer: ");
       // read the user's input as an integer
        int num = scanner.nextInt();
        scanner.close();
        try {
      // check if the input number is positive, throw an exception if it's not
            if (num < 0) {
                throw new IllegalArgumentException("Number must be positive");
            }
            int result = 100 / num;
            System.out.println("Result: " + result);
        } catch (IllegalArgumentException e) {
            // create a new exception with the original Exception as the cause
            throw new RuntimeException("Invalid input", e);
        } catch (ArithmeticException e) {
            // create a new exception with the original Exception as the cause
            throw new RuntimeException("Error: division by zero", e);
        }
    }
}

Output:

Enter a positive integer: -9
Exception in thread "main" java.lang.RuntimeException: Invalid input at ChainedExceptionExample.main(ChainedExceptionExample.java:17)
Caused by: Java.lang.IllegalArgumentException: Number must be positive at ChainedExceptionExample.main(ChainedExceptionExample.java:11)

Difference Between non chained and chained Exception

Non-chained exceptions	Chained exceptions
An exception occurs and is caught at the point where it occurs without any reference to the original cause of the Exception.	The original cause of the Exception is preserved and reported along with the current Exception.
A lack of reference to the original cause can make debugging and troubleshooting more challenging.	Chained exceptions provide more context to the Exception and make it easier to identify and fix the root cause of the problem.
Suitable for small programs or simple systems where exceptions are limited and easy to identify	Particularly useful in large programs or complex systems where exceptions can be thrown across different components, as it can help identify where the problem first occurred and how it propagated through the system

Next TopicFinal static variable in Java

← prev next →