Exception Handling in Java

An object of
exception exception
Int data=10/0; class is thrown object

No Is Yes
handled
?

JVM
1)Prints out exception Rest of the code is
description executed
2) Prints the stack trace
3) Terminate the program
Exception
 An exception is an abnormal condition that arises in a code
sequence at run time.
 In other words, an exception is a 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.
 That method may choose to handle the exception itself, or
pass it on. Either way, at some point, the exception is caught
and processed.
Try-catch Block

try{
//statements that may cause an exception
}
catch (exception(type) e(object))
{
//error handling code
}
 Multiple catch
try { //Protected code
}
catch(ExceptionType1 e1)
{
//Catch block
}
catch(ExceptionType2 e2)
{
//Catch block
}
……
Sequence of Events
Preceding step

try block

statement

unmatched catch

matching catch

unmatched catch

next step
 class Example2{
public static void main(String args[]){

try{ int a[]=new int[7];

a[4]=30/0; }
catch(ArithmeticException e) {
System.out.println("Warning: ArithmeticException"); }

catch(ArrayIndexOutOfBoundsException e){
System.out.println("Warning:ArrayIndexOutOfBoundsException"); }

catch(Exception e){
System.out.println("Warning: Some Other exception"); }

System.out.println("Out of try-catch block...");

}
}
 Nested try catch
 One try-catch block can be present in the another try’s
body. This is called Nesting of try catch blocks.
 Each time a try block does not have a catch handler for
a particular exception, the stack is unwound and the
next try block’s catch (i.e., parent try block’s catch)
handlers are inspected for a match.
 If no catch block matches, then the java run-time
system will handle the exception.
 Syntax of Nested try Catch
try
{ statement 1;

try {
statement 2; }
catch(Exception e1) {
//Exception Message }
}
catch(Exception e2) //Catch of Main(parent) try block
{ //Exception Message
}
 What is Finally Block
A finally statement must be associated with
a try statement.

 It identifies a block of statements that needs to be

executed regardless of whether or not an exception
occurs within the try block.

 It will run regardless of whether an exception was

thrown and handled by the try and catch parts of the
block.
 Try-catch-finally
• In normal execution the finally block is executed after try block.
• When any exception occurs first the catch block is executed and
then finally block is executed.

Try
{
Try ……
{ }
……. catch(…)
} { ……..
Finally }
{ Finally
……… {
} }
 Program Code

Exception Yes
no
Occurred
?

no Yes
Exception
Handled ?

Finally block is executed

Sequence for finally clause

Preceding step
try block

statement

unmatched catch
matching catch
unmatched catch
finally
next step
class Simple{
public static void main(String args[]){
try{
int data=25/0;
System.out.println(data);
}
catch(ArithmeticException e){
System.out.println(e);
}
finally{
System.out.println("finally block is always executed");
}
System.out.println("rest of the code...");
} }
 Throwing our Own Exceptions
throw keyword

 In java we have already defined exception classes such as ArithmeticException, NullPointerException etc.

 These exceptions are implicitly thrown by JVM

 The throw keyword is used to explicitly throw an exception.

 These exceptions are known as user-defined exceptions.

 The general form of throw is shown here:

throw ThrowableInstance;

 Here, ThrowableInstance must be an object of type Throwable or a subclass of Throwable.

 Primitive types, such as int or char, as well as non-Throwable classes, such as String and Object, cannot be used

as exceptions.
Syntax of throw statement

throw new AnyThrowableInstance;

IOException e = new IOException();

throw e;
class MyException extends Exception {
public MyException (String msg) { super(msg); }
}
class TestMyException {
public static void main(String[] args) {
int age=-2;
try {
if(age < 0)
throw new MyException("Age can't be less than zero");
}
catch (MyException e) {
e.printStackTrace();
}
 throws keyword
 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.
 You do this by including a throws clause in the method’s declaration.
 The throws keyword is used to declare an exception.
 It gives an information to the programmer that there may occur an
exception.
 So it is better for the programmer to provide the exception handling
code so that normal flow can be maintained.
Syntax of throws keyword:

void method_name() throws exception_class_name

{
...
}
import java.io.*;
class M {
void method() throws IOException{
throw new IOException("device error");
}
}
classTest{
public static void main(String args[])throws IOException{
Test t=new Test();
t.method();
System.out.println("normal flow...");
}
}
 throw keyword throws keyword

throw is used to explicitly throw an throws is used to declare an

exception. exception.
checked exception can not be checked exception can be propagated
propagated without throws. with throws.
throw is followed by an instance. throws is followed by class.

throw is used within the method. throws is used with the method
signature.
You cannot throw multiple You can declare multiple exception
exception e.g.
public void method()throws
IOException,SQLException.
 Java’s Built-in Exceptions: Unchecked
 Inside the standard package

java.lang, Java defines

several exception classes.

 The most general of these

exceptions are subclasses of

the standard type
RuntimeException.

 These are called unchecked

exceptions because the

compiler does not check to
see if a method handles or
throws these exceptions.
Java’s Built-in Exceptions: Checked
 Chained Exception
 The chained exception feature allows you to associate another exception with an exception.

 This second exception describes the cause of the first exception.

 For example, imagine a situation in which a method throws an ArithmeticException

because of an attempt to divide by zero.

 However, the actual cause of the problem was that an I/O error occurred, which caused the

divisor to be set improperly.

 Although the method must certainly throw an ArithmeticException, since that is the error that

occurred, you might also want to let the calling code know that the underlying cause was an
I/O error.

 Chained exceptions let you handle this, and any other situation in which layers of exceptions

exist.
// Demonstrate exception
chaining.
class ChainExcDemo {
static void demoproc() {
// create an exception
NullPointerException e = new
NullPointerException("top
layer");
// add a cause
e.initCause(new The output from the program is shown here:
Caught: java.lang.NullPointerException: top layer
ArithmeticException("cause"));
Original cause: java.lang.ArithmeticException: cause