Explain Try And Catch Block In Java With Program And Examples
In This Topic & Blog Having Any Query Then Post your Comment and Suggestion Below
Using try and 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 two
benefits. First, it allows you to fix the error. Second, it prevents the program from automatically
terminating. Most users would be confused (to say the least) 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. 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:
class Exc2 {
public static void main(String args[]) {
int d, a;
try { // monitor a block of code.
d = 0;
a = 42 / d;
System.out.println("This will not be printed.");
} catch (ArithmeticException e) { // catch divide-by-zero error
System.out.println("Division by zero.");
}
System.out.println("After catch statement.");
}
}
This program generates the following output:
Division by zero.
After catch statement.
Notice that the call to
println( )
inside the
try
block is never executed. Once an exception
is thrown, program control transfers out of the
try
block into the
catch
block. Put differently,
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 has 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
try
statement. A
catch
statement
cannot catch an exception thrown by another
try
statement (except in the case of nested
try
statements, described shortly). The statements that are protected by
try
must be surrounded
by curly braces. (That is, they must be within a block.) You cannot use
try
on a single statement.
The goal of most well-constructed
catch
clauses should be to resolve the exceptional
condition and then continue on as if the error had never happened. For example, in the next
program each iteration of the
for
loop obtains two random integers. Those two integers are
divided by each other, and the result is used to divide the value 12345. The final result is put
into
a
. If either division operation causes a divide-by-zero error, it is caught, the value of
a
is
set to zero, and the program continues.
// Handle an exception and move on.
import java.util.Random;
class HandleError {
public static void main(String args[]) {
int a=0, b=0, c=0;
Random r = new Random();
for(int i=0; i<32000; i++) {
try {
b = r.nextInt();
c = r.nextInt();
a = 12345 / (b/c);
} catch (ArithmeticException e) {
System.out.println("Division by zero.");
a = 0; // set a to zero and continue
}
System.out.println("a: " + a);
}
}
}
Displaying a Description of an Exception
Throwable
overrides the
toString( )
method (defined by
Object
) so that it returns a string
containing a description of the exception. You can display this description in a
println( )
statement by simply passing the exception as an argument. For example, the
catch
block
in the preceding program can be rewritten like this:
catch (ArithmeticException e) {
System.out.println("Exception: " + e);
a = 0; // set a to zero and continue
}
When this version is substituted in the program, and the program is run, each divide-by-
zero error displays the following message:
Exception: java.lang.ArithmeticException: / by zero
While it is of no particular value in this context, the ability to display a description of
an exception is valuable in other circumstances—particularly when you are experimenting
with exceptions or when you are debugging.