Java try catch

Although the default exception handler provided by the Java run-time system is useful for debugging, you will usually want to handle an exception yourself. Doing so provides the following two benefits:

1. It allows you to fix the error.
2. It prevents the program from automatically terminating.

Most users would be confused if your program stopped running and printed a stack trace whenever an error occurred. Fortunately, it is quite easy to prevent this.

To guard against and handle a run-time error, simply enclose the code that you want to monitor inside a try block. Immediately following the try block, include a catch clause that specifies the exception type that you wish to catch.

Java try catch Example

To illustrate how easily this can be done, the following program includes a try block and a catch clause that processes the ArithmeticException generated by the division-by-zero error :

/* Java Program Example - Java try and catch
 * This program illustrates the uses of try 
 * and catch in Java */
 
 class JavaProgram
 {
     public static void main(String args[])
     {
         int denom = 0, num = 52, res;
         
         try {      // monitor a block of code
             
             res = num / denom;
             System.out.println("This will not be printed");
             
         } catch(ArithmeticException e) {       // catch divide-by-zero error
             
             System.out.println("Division by zero Error..!!");
         }
         
         System.out.println("After catch statement");
     }
 }

When the above Java program is compile and executed, it will produce the following output:

Notice that the call to println() inside the try block is never executed. Once an exception is thrown, program control transfers out of try block into catch block. Put differently, the catch is not "called", so execution never "returns" to the try block from a catch. Thus, the line "This will not be printed" is not displayed. Once the catch statement is executed, program control continues with the next line in the program following the entire try / catch mechanism.

A try and its catch statement form a unit. The scope of the catch clause is restricted to those statements specified by the immediately preceding the try statement. A catch statement cannot catch an exception thrown by another try statement (except in the case of nested try statements). The statements that are protected by the try must be surrounded by curly braces i.e., they must be within a block. You cannot use try on a single statement.

The goal of most well-constructed catch clause should be to resolve the exceptional condition and then continue on as if the error had never happened. For example, in the upcoming example program each iteration of the for loop obtains the two random integers. Those two integers are divided by each other, and the result is used to divide the value 23456. The final result is put into variable x. If either division operation causes a divide-by-zero error, it is caught, the value of x is set to zero, and the program continues.

/* Java Program Example - Java try and catch
 * This program handle an exception and 
 * move on */
 
 import java.util.Random;
 
 class JavaProgram
 {
     public static void main(String args[])
     {
         
         int x = 0, y = 0, z = 0;
         
         Random ran = new Random();
         
         for(int i=0; i<20; i++)
         {
             try {
                 
                 y = ran.nextInt();
                 z = ran.nextInt();
                 x = 23456 / (y/z);
                 
             } catch (ArithmeticException e) {
                 
                 System.out.println("Division by zero error..!!");
                 x = 0;      // set x to zero and continue
                 
             }
             
             System.out.println("x : " + x);
             
         }
         
     }
 }

When the above Java program is compile and executed, it will produce the following output:

Java Online Test