Java try catch

Java try catch

There can be statements that can cause exceptions, and the exception leads to abnormal termination of the program. To avoid that abnormal termination, those statements that look potent to raise an exception should be put in the try block. The catch block executes when an exception is raised in the try block.  By using the Java try-catch block, we can handle the exception. In this topic, we are going to discuss how try-catch block helps to handle exceptions.

Java try-catch syntax

The syntax of the try-catch is as follows:

 try
{
//statements that may cause exceptions
}
catch(ExceptionClass obj)
{
//statements
} 

Significance of Java try-catch block

Let’s try to understand what will happen if one omits the try-catch block with the help of a program.

FileName: TryCatchExample.java

 public class TryCatchExample
{ 
// main method
public static void main(String argvs[])
{
int val = 70 / 0; // statement responsible for exception. Line no 7
// print statement
System.out.println("The division operation has been successfully completed.");
}
} 

Output:

Explanation: Observe that the print statement does not get executed. It is because of the exception raised at line number 7. The exception causes the abnormal termination of the program, and this behavior is not correct. Those statements that are not causing the exception should be executed, and their output should be displayed. To achieve the same, the Java try-catch block is used. Let’s see how to handle the above exception.

FileName: TryCatchExample1.java

 public class TryCatchExample1
{ 
// main method
public static void main(String argvs[])
{
try
{
int val = 70 / 0;
}
catch(ArithmeticException e)
{
System.out.println(e);  
}
// print statement
System.out.println("The division operation has been successfully completed.");
}
} 

Output:

Explanation: Now, we observe that the exception is handled. The print statement that followed the catch block got executed at this time, and the program terminates normally.

Proper Handling of Java try-catch

One should understand that the Java try-catch blocks should be handled with care. Suppose, one is sure that some statements in the code that do not throw exceptions, then such statements should not be put in the try block. Observe the following code.

FileName: TryCatchExample2.java

 public class TryCatchExample2
{ 
// main method
public static void main(String argvs[])
{
try
{
int val = 70 / 0; // line 8
// print statement 1
System.out.println("Hello Java. The language is awesome.");
}
catch(ArithmeticException e)
{
System.out.println(e);  
}
// print statement 2
System.out.println("The division operation has been successfully completed.");
}
} 

Output:

Explanation: Notice the first print statement (at line 10) does not get printed. The reason for the non-execution of the first print statement is line 8. At line 8, the java.lang.ArithmeticeException is raised. Therefore, the control shifts to the catch block. Thus, any statement that is inside the try block and follows line 8 never gets executed. Hence, the first print statement is not get printed on the console. The appropriate way is to put print statement 1 outside the try-catch block. Thus, we can say that only those statements that can raise an exception should be put inside the try block.

Working of the try-catch Block

The following flow diagram demonstrates the working of the try-catch block.

Remember:

• It is not possible to have multiple try blocks with a single catch block. If we try to do the same, a compile-time error is generated.
• Each try block must be followed by at least one catch block or finally.
• There can be multiple catch blocks for one try block. Multiple catch blocks come in very handy to handle each exception in a different way.
• A catch block may handle multiple type exceptions. Ensure that each type of exception is separated by a vertical bar (|). It reduces code duplication and increases efficiency. For example:

 try
{
// code
}
catch (ExceptionType1 | Exceptiontype2 | Exceptiontype2 ex)
{
// catch block
} 

Even though multiple catch blocks can be present for a single try block, at a time, only one catch block is executed. The ordering of the catch blocks should always be from specific to general, which means the ArithmeticException should always come before the Execption; otherwise, a compilation error is thrown.

FileName: TryCatchExample3.java

 public class TryCatchExample3
{ 
// main method
public static void main(String argvs[])
{
try
{   
int arr[] = new int[6];  // line 9
// arr[6] = 8; // line 10 
arr[6] = 130 / 0; // line 11
}   
// multiple catch blocks for handling different types of exception
catch(ArithmeticException ae) 
{ 
  System.out.println("In the Arithmetic Exception catch block " + ae); 
}   
catch(ArrayIndexOutOfBoundsException aie) 
{ 
  System.out.println("In the ArrayIndexOutOfBounds Exception catch block. " + aie); 
}   
catch(Exception ex) 
{ 
  System.out.println("In the Parent Exception catch block " + ex); 
}     
System.out.println("Code after the try catch block.");   
}
} 

Output:

Explanation: It is obvious by looking at the output that only the catch block of ArithmeticException got exsecuted, and the reason for this is line 11. Line 11 is potent to generate two exceptions one is ArithmeticException (130 / 0), and another is ArrayIndexOutOfBounds (arr[6]) exception. However, the operation 130 / 0 is executed first, and hence, the ArithmeticException is also raised first. In order to raise the ArrayIndexOutOfBounds exception, uncomment line 10.