«Back to Home

Core Java
Topics

Nested Try Block In Java

Nested Try Block
 
When we use one try block in another try block, it is called as nested try block in Java.
 
In other words, Java try catch blocks can be nested. One try-catch block can be present in another try block. Due to this, it is called as nesting of try catch blocks. Every time, a try block doesn’t have a catch handler for a particular exception. Thus, the stack is unwound and the next try block’s catch handlers are checked for a match. If no catch block matches, the JVM will handle the exception.
 
Why we use nested try block
 
Nested try block is used when some situation may arise, where a part of a block may cause one error and the other whole block itself may cause a different error. In this case, exception handlers have to be nested in Java.
 
Syntax
....
try       // main try block
{
    Statement 1;
    Statement 2;
        try      //try-catch block inside another try block
        {
           Statement 3;
           Statement 4;
        }
          catch(Exception e)
        {
        }
}
catch(Exception e1)
{
}
....
Let's see an example, given below.
 
Code
  1. package exceptionHandling;  
  2. public class NestedExample {  
  3.     public static void main(String args[]) {  
  4.         try {  
  5.             try {  
  6.                 System.out.println("Division");  
  7.                 int x = 63 / 0;  
  8.             } catch (ArithmeticException e) {  
  9.                 System.out.println(e);  
  10.             }  
  11.             try {  
  12.                 int a[] = new int[7];  
  13.                 a[7] = 26;  
  14.             } catch (ArrayIndexOutOfBoundsException e) {  
  15.                 System.out.println(e);  
  16.             }  
  17.             System.out.println("Next statement...");  
  18.         } catch (Exception e) {  
  19.             System.out.println("Exception handeled");  
  20.         }  
  21.         System.out.println("Rest code..");  
  22.     }  
  23. }  
11

Output

12

In the example shown above, nested try catch is used in Java.
 
The main point in this example is that when the inner try-catch blocks are not handling any exception, the flow of control comes back to the outer try-catch block and if the exception is not handled in the outer try-catch block also, the program will terminate immediately.
 
Summary

Thus, we learnt that if we use one try block in another try block, it is known as nested try block and also learnt why we need to use it in Java.