1
Exception Handling in
Java
Types of Errors
1.Compile time
All syntax errors identified by java
compiler.
No class file is created when this occurs.
So it is necessary to fix all compile time
errors for successful compilation.
Egs:
Missing of semicolon,
use of = instead of ==
Exception Handling in
Java
2.Run time
Some pgms may not run successfully due
to wrong logic or errors like stack
overflow.
Some of the Common run time errors are:
Division by 0
Array index out of bounds
Negative array size etc..
3
Exception Handling in
Java
Exception is a condition caused by a run time
error in the program. When the java interpreter
identifies an error such as division by 0 it
creates an Exception object and throws it
Definition:
An exception is an event, which occurs during
the execution of a program, that disrupts the
normal flow of the program's instructions.
Is defined as a condition that interrupts the
normal flow of operation within a program.
4
Exception Handling in Java
Java allows Exception handling mechanism to
handle various exceptional conditions. When an
exceptional condition occurs, an exception is
said to be thrown.
For continuing the program execution, the user
should try to catch the exception object thrown
by the error condition and then display an
appropriate message for taking corrective
actions. This task is known as Exception
handling
5
Exception Handling in
Java
This mechanism consists of :
1. Find the problem(Hit the Exception)
2. Inform that an error has occurred(Throw
the Exception)
3. Receive the error Information(Catch the
Exception)
4. Take corrective actions(Handle the
Exception)
Exception Handling in
Java
In Java Exception handling is managed by 5
key words:
try
catch
throw
throws
finally
Exception Handling in Java
Exception
Hierarchy
Package java.lang
Throwable
Exception
InterruptedException
(checked exception)
error
RuntimeException
(unchecked exception)
Exception Handling in Java
Unchecked exception:
These exception need not be included in an
methods throws list
The compiler does not check to see if a method
handles or throws these exception
these are subclasses of RuntimeException
The compiler doesn't force client programmers
either to catch the exception or declare it in a
throws clause.
Class Error and its subclasses also are unchecked.
Checked exception:
Must be included in an methods throws list if that
method can generate one of those exceptions and does
not handle it itself
These exception defined by java.lang
Exception Handling in Java
Javas unchecked RuntimeException subclasses defined in java.lang
Exception
Meaning
ArithmeticException
Arithmetic error, such as divide-by-zero
ArrayIndexOutOfBoundsException
Array index is out-of-bounds
ArrayStoreException
Assignment to an array element of an
incompatible type
ClassCastException
Invalid cast
EnumConstantNotPresentException An attempt is made to use an undefined
enumeration value
IllegalArgumentException
Illegal argument used to invoke a method
IllegalMonitorStateException
Illegal monitor operation, such as waiting on
an unlocked thread
IllegalStateException
Environment or application is in incorrect
state
IllegalThreadStateException
Requested operation not compatible with
current thread state
IndexOutOfBoundsException
Some type of index is out-of-bounds
NegativeArraySizeException
Array created with a negative size
10
Exception Handling in Java
Exception
Meaning
NullPointerException
Invalid use of a null reference
NumberFormatException
Invalid conversion of a string to a numeric
format
SecurityException
Attempt to violate security
StringIndexOutOfBoundsException
Attempt to index outside the bounds of a
string
TypeNotPresentException
Type not fount
UnsupportedOperationException
An unsupported operation was encountered
11
Exception Handling in Java
Javas checked Exception defined in java.lang
Exception
Meaning
ClassNotFoundException
Class not found
CloneNotSupportedException
Attempt to clone an object that does not
implement the Cloneable interface
IllegalAccessException
Access to a class is denied
InstantiationException
Attempt to create an object of an abstract
class or interface
InterruptedException
One thread has been interrupted by another
thread
NoSuchFieldException
A requested field does not exist
NoSuchMethodException
A requested method does not exist
12
Exception Handling in Java
class Ex{
public static void main(String args[]){
int a=0;
int b=2/a;
}
}
Java.lang.ArithmeticException: / by zero
at Ex.main
13
Exception Handling in
Java
try & catch
try Block
Statement that
causes Exception
Catch Block
Statement that
causes Exception
14
Exception Handling in
Java
try{
Statement:
}
catch(Exception-type e){
statement;
}
15
Exception Handling in
Java
class Ex{
public static void main(String args[]){
int d,a;
try{
d=0;
a=10/d;
System.out.println("from try");
}catch(ArithmeticException e)
{
System.out.println("divsn by Zero");
}
System.out.println("after catch");
}
}
Once an exception is
thrown , program control
transfers out of the try
block into the catch block.
Once the catch statement
is executed pgm control
continues with the next
line following the entire
try/catch mechanism.
16
Exception Handling in
Java
We can display the description of an Exception in
a println statement by simply passing the
exception as an argument.
catch(ArithmeticException ae){
System.out.println(Exception:+ae);
}
o/p
Exception:java.lang.ArithmeticException: /by
zero
17
Exception Handling in Java
Common Throwable
methods
getMessage(); All throwable objects can have an
associated error message. Calling this message will
return the message if one present.
getLocalizedMessage(); gets the localized version of
error message.
printStackTrace(); sends the stack trace to the system
console. This is a list of method calls that led to the
exception condition. It includes line number and file
names too. Printing of the stack trace is the default
behavior of a runtime exception when u dont catch it
ourselves.
18
Exception Handling in Java
Use of getMessage() and
printStackTrace()
catch(ArithmeticException e){
System.out.println(e.getMessage());
//e.printStackTrace();
}
o/p:E:\JAVAPGMS>java Ex
/ by zero
catch(ArithmeticException e){
e.printStackTrace();
}
E:\JAVAPGMS>java Ex
o/p:
java.lang.ArithmeticException: / by zero
at Ex.main(Ex.java:9)
19
Exception Handling in Java
Multiple catch Statement
some cases, more than one exception could be raised by
a single piece of code.
such cases we can specify two or more catch clauses,
each catching a different type of exception.
when an exception thrown, each catch statement is
inspected in order, and the first one whose type matches
that of the exception is executed.
After 1 catch statement is executed, the others are
bypassed and execution continues after the try/catch
block.
20
Exception Handling in
Java
class Ex{
public static void main(String
args[]){
int d,a,len;
try{
len=args.length;
a=10/len;
int c[]={1};
catch(ArithmeticException e){
c[10]=23;
System.out.println("divsn by
}
Zero"+e);
}
catch(ArrayIndexOutOfBoundsExcept
ion ae){
System.out.println("Array index"+ae);
}
System.out.println("after catch");
}
}
21
Exception Handling in
Java
In multiple catch statement exception subclasses
must come before any of their superclasses.
Because a catch statement that uses a
superclass will catch exception of that type plus
any of its subclasses.
Thus a subclass would never be reached if it
came after its superclass.
Further java compiler produces an error
unreachable code.
22
Exception Handling in
Nested tryJava
statement
try statement can be nested
class Ex{
public static void main(String dd[]){
int d,a,len;
try{
len=dd.length;
a=10/len;
System.out.println(a);
catch(ArrayIndexOutOfBoundsExceptio
try{
n ae){
if(len==1)
System.out.println("Array index"+ae);
len=len/(len-len);
}
if(len==2){
}
int c[]={1};
catch(ArithmeticException e){
c[10]=23;
e.printStackTrace();
}
}
}
}
System.out.println("after catch");
}
}
23
Exception Handling in Java
E:\JAVAPGMS>java Ex
java.lang.ArithmeticException: / by zero
at Ex.main(Ex.java:9)
after catch
E:\JAVAPGMS>java Ex 20
10
java.lang.ArithmeticException: / by zero
at Ex.main(Ex.java:14)
after catch
E:\JAVAPGMS>java Ex 20 30
5
Array indexjava.lang.ArrayIndexOutOfBoundsException: 10
after catch
24
Exception Handling in
Java
throw
It is possible to throw an exception explicitly.
Syntax:
throw ThrowableInstance
throwableInstance must b an object of type Throwable or a
subclass of Throwable.
By two ways we can obtain a Throwable object
1. Using parameter into a catch clause
2. Creating one with new operator
25
Exception Handling in
Java
class throwDemo{
public static void main(String args[]){
int size;
int arry[]=new int[3];
size=Integer.parseInt(args[0]);
try{
if(size<=0)throw new
NegativeArraySizeException("Illegal
Array size");
for(int i=0;i<3;i++)
arry[i]+=i+1;
}catch(NegativeArraySizeException e){
System.out.println(e);
}
}
}
26
Exception Handling in
Java
E:\JAVAPGMS>java throwDemo -4
java.lang.NegativeArraySizeException:
Illegal Array size
Exception in thread "main"
java.lang.NegativeArraySizeException:
Illegal Array size
at
throwDemo.main(throwDemo.java:17)
27
throws
Exception Handling in
Java
If a method causing an exception that it doesn't
handle, it must specify this behavior that callers
of the method can protect themselves against
the exception.
This can be done by using throws clause.
throws clause lists the types of exception that a
method might throw.
Form
type methodname(parameter list) throws
Exception list
{//body of method}
28
Exception Handling in
Java
import java.io.*;
class ThrowsDemo{
public static void main(String args[])throws
IOException,NumberFormatException{
int i;
InputStreamReader in=new
InputStreamReader(System.in);
BufferedReader br=new BufferedReader(in);
i=Integer.parseInt(br.readLine());
System.out.println(i);
}}
29
finally
Exception Handling in
Java
It creates a block of code that will be executed after try/catch
block has completed and before the code following try/catch
block.
It will execute whether or not an exception is thrown
finally is useful for:
Closing a file
Closing a result set
Closing the connection established with database
This block is optional but when included is placed after the last
catch block of a try
30
Exception Handling in
Java
Form:
try
try block
{}
catch(exceptiontype
e)
{}
finally
Catch block
finally
{}
finally
31
Exception Handling in
Creating Java
our own Exception class
For creating an exception class our own simply
make our class as subclass of the super class
Exception.
Eg:
class MyException extends Exception{
MyException(String msg){
super(msg);
}
}
32
Exception Handling in Java
class TestMyException{
public static void main(String args[]){
int x=5,y=1000;
try{
float z=(float)x/(float)y;
if(z<0.01){
throw new MyException("too small number");
}
}catch(MyException me){
System.out.println("caught my exception");
System.out.println(me.getMessage());
}
finally{
System.out.println("from finally");
}
}
}
33
Exception Handling in Java
O/P:
E:\JAVAPGMS>java
TestMyException
caught my exception
too small number
from finally
34
