EXCEPTION

HANDLING
1

 An exception is an abnormal condition that

arises in a code sequence at run-time(run-time
error)
A Java exception is an object that describes an
exceptional (that is, error) condition that has
occurred in a piece of code
When an exceptional condition arises, an object
representing that exception is created and
thrown in the method that caused the error
The exception is caught and processed

 Java exception handling is managed via five

keywords: try, catch, throw, throws, and
finally
Program statements that you want to monitor
for exceptions are contained within a try block
If an exception occurs within the try block, it is
thrown
Your code can catch this exception (using
catch) and handle it
3

 System-generated exceptions are automatically

thrown by the Java run-time system
To manually throw an exception, use the
keyword throw
Any exception that is thrown out of a method
must be specified as such by a throws clause
Any code that absolutely must be executed
before a method returns is put in a finally
block
4

 This is the general form of an exceptionhandling block:

try {
// block of code to monitor for errors
}
catch (ExceptionType1 exOb) {
// exception handler for ExceptionType1 }
catch (ExceptionType2 exOb) {
// exception handler for ExceptionType2 }
// ...
finally {
// block of code to be executed before try
block ends }
5

Exception Types
All exception types are subclasses of the
built-in class Throwable
Immediately below Throwable are two
subclasses that partition exceptions into two
distinct branches
One branch is headed by Exception
This class is used for exceptional conditions
that user programs should catch
6

 There is an important subclass of

Exception, called RuntimeException
Exceptions of this type are automatically
defined for the programs that you write
and include things such as division by zero
and invalid array indexing

 The other branch is topped by Error,

which defines exceptions that are not
expected to be caught under normal
circumstances by your program
Exceptions of type Error are used by the
Java run-time system to indicate errors
having
to
do
with
the
run-time
environment, itself
Stack overflow is an example of such an
error
8

Uncaught Exceptions
class Exc0 {
public static void main(String args[]) {
int d = 0;
int a = 42 / d;
}
}
Java run-time constructs a new exception object
and then throws this exception. This causes the
execution of Exc0 to stop, because once an
exception has been thrown, it must be caught by
an exception handler and dealt with immediately.
The default handler displays a string describing
the exception, prints a stack trace from the point
at which the exception occurred, and terminates
the program.

 Output: java.lang.ArithmeticException: / by zero

at Exc0.main(Exc0.java:4)
class Exc1 { //method separated from main()
static void subroutine() {
int d = 0;
int a = 10 / d;
}
public static void main(String args[]) {
Exc1.subroutine();
}
}
The resulting stack trace from the default
exception handler shows how the entire call
stack is displayed:
java.lang.ArithmeticException: / by zero
at Exc1.subroutine(Exc1.java:4)
at Exc1.main(Exc1.java:7)

Using try and catch:

Handling an exception manually provides
two benefits
First, it allows you to fix the error
Second, it prevents the program from
automatically terminating
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.
11

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 divideby-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.
12

 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
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.
13

// 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);
}
}
}

14

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.

catch (ArithmeticException e) {
System.out.println("Exception: " + e);
a = 0; // set a to zero and continue
}
Exception: java.lang.ArithmeticException: / by
zero
15

Multiple catch Clauses

// Demonstrate multiple catch statements.
class MultiCatch {
public static void main(String args[]) {
try {
int a = args.length;
System.out.println("a = " + a);
int b = 42 / a;
int c[] = { 1 };
c[42] = 99;
} catch(ArithmeticException e) {
System.out.println("Divide by 0: " + e);
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Array index oob: " + e); }
System.out.println("After try/catch blocks.");
} }
16

 The output generated by running it both ways:

C:\>java MultiCatch
a=0
Divide by 0: java.lang.ArithmeticException: / by zero
After try/catch blocks.
C:\>java MultiCatch TestArg
a=1
Array index oob:
java.lang.ArrayIndexOutOfBoundsException
After try/catch blocks.
When more than one exception could be raised by a
single piece of code, you can specify two or more catch
clauses.
each catch statement is inspected in order, and the
first one whose type matches that of the exception is
executed. After one catch statement executes, the
others are bypassed, and execution continues after the
try/catch block.

/* This program contains an error. A subclass must

come before its superclass in a series of catch
statements. If not, unreachable code will be
created and a compile-time error will result. */
class SuperSubCatch {
public static void main(String args[]) {
try {
int a = 0;
int b = 42 / a;
} catch(Exception e) {
System.out.println("Generic Exception catch."); }
/* This catch is never reached because
ArithmeticException is a subclass of Exception. */
catch(ArithmeticException e) { // ERROR unreachable
System.out.println("This is never reached.");
} }
}
18

Nested try Statements:

The try statement can be nested
Each time a try statement is entered, the
context of that exception is pushed on the
stack.
If an inner try statement does not have a
catch handler for a particular exception, the
stack is unwound and the next try
statements catch handlers are inspected
for a match.
This continues until one of the catch
statements succeeds, or until all of the
nested try statements are exhausted. If no
catch statement matches, then the Java
run-time system will handle the exception.19

// An example of nested try statements.

class NestTry {
public static void main(String args[]) {
try {
int a = args.length;
/* If no command-line args are present,
the following statement will generate
a divide-by-zero exception. */
int b = 42 / a;
System.out.println("a = " + a);
try {
// nested try block
/* If one command-line arg is used, then
divide-by-zero exception will be generated by
the following code. */
if(a==1) a = a/(a-a); // division by zero

/* If two command-line args are used,

then generate an out-of-bounds exception. */
if(a==2) {
int c[] = { 1 };
c[42] = 99; // generate an out-of-bounds
exception
}
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Array index out-of-bounds: "
+ e);
}
} catch(ArithmeticException e) {
System.out.println("Divide by 0: " + e);
} }
}

 When you execute the program with no

command-line arguments, a divide-by-zero
exception is generated by the outer try block.
Execution of the program by one command-line
argument generates a divide-by-zero exception
from within the nested try block. Since the inner
block does not catch this exception, it is passed
on to the outer try block, where it is handled.
If you execute the program with two commandline arguments, an array boundary exception is
generated from within the inner try block.
Output will beC:\>java NestTry
Divide by 0: java.lang.ArithmeticException: / by
zero

C:\>java NestTry One

a=1
Divide by 0: java.lang.ArithmeticException: /
by zero
C:\>java NestTry One Two
a=2
Array index out-of-bounds:
java.lang.ArrayIndexOutOfBoundsException

throw:
It is possible for your program to throw an
exception
explicitly,
using
the
throw
statement
The general form of throw is shown here:
throw ThrowableInstance;
23

 Here, ThrowableInstance must be an object of type

Throwable or a subclass of Throwable
There are two ways you can obtain a Throwable
object: (i) using a parameter into a catch clause,
(ii) creating one with the new operator
The flow of execution stops immediately after the
throw statement; any subsequent statements are
not executed
The nearest enclosing try block is inspected for
catch. If it finds one, control is transferred to that,
otherwise, the next enclosing try block and so on. If
no match, default handler haults the program and
prints the stack trace.
24

class ThrowDemo {
// Demonstrate
throw.
static void demoproc() {
try {
throw new NullPointerException("demo");
} catch(NullPointerException e) {
System.out.println("Caught inside
demoproc.");
throw e; // rethrow the exception
}
}
public static void main(String args[]) {
try {
demoproc();
} catch(NullPointerException e) {
System.out.println("Recaught: " + e);
}}}

25

throws
Output:
Caught inside demoproc.
Recaught: java.lang.NullPointerException: demo

If a method is capable of causing an exception that it

does not handle, it must specify this behavior so that
callers of the method can guard themselves against
that exception

A throws clause lists the types of exceptions that a

method might throw

26

 Exceptions that a method can throw must be

declared in the throws clause
This is the general form of a method
declaration that includes a throws clause:
type
method-name(parameter-list)
throws
exception-list
{
// body of method
}
Here, exception-list is a comma-separated list
of the exceptions that a method can throw
27

// This program contains an error and will

not compile.
class ThrowsDemo {
static void throwOne() {
System.out.println("Inside throwOne.");
throw new
IllegalAccessException("demo");
}
public static void main(String args[ ]) {
throwOne();
}
}
28

class ThrowsDemo {
static void throwOne() throws IllegalAccessException {
System.out.println("Inside throwOne.");
throw new IllegalAccessException("demo");
}
public static void main(String args[]) {
try {
throwOne();
} catch (IllegalAccessException e) {
System.out.println("Caught " + e);
}
}
}
Here is the output generated by running this example
program:
inside throwOne
caught java.lang.IllegalAccessException: demo
29

finally
finally creates a block of code that will be
executed after a try/catch block has
completed and before the code following the
try/catch block
The finally block will execute whether or not
an exception is thrown
If an exception is thrown, the finally block
will execute even if no catch statement
matches the exception
30

 The finally clause is optional

Each try statement requires at least
one catch or a finally clause

31

// Demonstrate finally.
class FinallyDemo {
// Through an exception out of the method.
static void procA() {
try {
System.out.println("inside procA");
throw new RuntimeException("demo");
} finally {
System.out.println("procA's finally");
}
}
// Return from within a try block.
static void procB() {
try {
System.out.println("inside procB");
return;
} finally {
System.out.println("procB's finally");
}
}
32

// Execute a try block normally.

static void procC() {
try {
System.out.println("inside procC");
} finally {
System.out.println("procC's finally");
}
}
public static void main(String args[]) {
try {
procA();
} catch (Exception e) {
System.out.println("Exception caught");
}
procB();
procC();
}
}

33

Here is the output generated by the

preceding program:
inside procA
procAs finally
Exception caught
inside procB
procBs finally
inside procC
procCs finally
34

Javas Built-in Exceptions

35

36

37