Nested try blocks in Exception Handling in Java

In Java, we can use a try block within another try block. This is called nested try blocks. Each time a try statement is entered, the context of that exception is pushed onto a stack. If an exception occurs in the inner try block and is not caught by its corresponding catch block, the exception propagates to the outer try block. This process continues until the exception is either caught or reaches the default exception handler.

• Nested try blocks are useful for handling exceptions at different levels of code.
• If an exception occurs in a parent try block, the control jumps directly to the matching catch block in the parent or outer try block, and any nested try blocks are skipped.
• If an exception occurs in an inner try block and is not caught, it propagates to the outer try block.

Basic Nested Try Blocks

Example 1: This example demonstrates nested try-catch blocks, where an ArrayIndexOutOfBoundsException is caught in the outer block, and an ArithmeticException is handled in the inner block.

class Geeks {

    // Main method
    public static void main(String args[]) {
        // Main try block
        try {
            // Initializing array
            int a[] = { 1, 2, 3, 4, 5 };

            // Trying to print element at index 5
            System.out.println(a[5]); 

            // Inner try block (try-block2)
            try {
                // Performing division by zero
                int x = a[2] / 0; // This will throw ArithmeticException
            } catch (ArithmeticException e2) {
                System.out.println("Division by zero is not possible");
            }
        } catch (ArrayIndexOutOfBoundsException e1) {
            System.out.println("ArrayIndexOutOfBoundsException");
            System.out.println("Element at such index does not exist");
        }
    }
}

ArrayIndexOutOfBoundsException
Element at such index does not exist

Explanation: The outer try block attempts to access an element at index 5 of the array a[], which throws an ArrayIndexOutOfBoundsException. Since the exception occurs in the outer try block, the control immediately jumps to the corresponding catch block (catch (ArrayIndexOutOfBoundsException e1)). The inner try block is never executed because the exception in the outer block interrupts the flow. Therefore, the message "Division by zero is not possible" is not printed.

Why "division by zero is not possible" not printed on the Screen?

The exception (ArrayIndexOutOfBoundsException) occurs in the outer try block. When an exception occurs in a parent try block, the control immediately jumps to the matching catch block in the parent or outer try block. The inner try block is never executed because the exception in the outer block interrupts the flow.

Multiple Levels of Nested Try Blocks

Example 2: This example demonstrates multiple levels of nested try-catch blocks, where an ArrayIndexOutOfBoundsException is caught in the outermost block, and inner blocks handle specific exceptions.

class Geeks {

    // Main method
    public static void main(String args[]) {
        // Main try block
        try {
            // try-block2
            try {
                // try-block3
                try {
                    int arr[] = { 1, 2, 3, 4 };
                    System.out.println(arr[10]);
                } catch (ArithmeticException e) {
                    System.out.println("Arithmetic exception");
                    System.out.println(" try-block1");
                }
            } catch (ArithmeticException e) {
                System.out.println("Arithmetic exception");
                System.out.println(" try-block2");
            }
        } catch (ArrayIndexOutOfBoundsException e4) {
            System.out.print("ArrayIndexOutOfBoundsException");
            System.out.println(" main try-block");
        } catch (Exception e5) {
            System.out.print("Exception");
            System.out.println(" handled in main try-block");
        }
    }
}

ArrayIndexOutOfBoundsException main try-block

Explanation:

The innermost try block (try-block3) attempts to access an element at index 10 of the array arr[], which throws an ArrayIndexOutOfBoundsException. Since there is no matching catch block for ArrayIndexOutOfBoundsException in the innermost try block, the exception propagates to the next outer try block (try-block2). The try-block2 also does not have a matching catch block for ArrayIndexOutOfBoundsException, so the exception propagates further to the outermost try block. The outermost try block has a matching catch block for ArrayIndexOutOfBoundsException, so the control jumps to this block and executes the corresponding code.

Note: If an exception occurs in a parent try block, the control jumps directly to the matching catch block in the parent or outer try block, and any nested try blocks are skipped.