Exception Handling in Java

Jwala Prakash

1
 Exception Handling in Java

throw
It is possible to throw an exception explicitly.
Syntax:
throw ThrowableInstance
throwableInstance must be an object of type Throwable or a
subclass of Throwable.
By 2 ways v can obtain a Throwable object
1.Using parameter into a catch clause
2.Creating one with new operator

2
class throwDemo
{
public static void main(String s[])
{
int size;
int arry[]=new int[3];
size=Integer.parseInt(s[0]);
try
{ new operator used
if(size<=0)
throw new NegativeArraySizeException("Illegal Array size");
for(int i=0;i<3;i++)
arry[i]+=i+1;
parameter used into catch clause
}
catch(NegativeArraySizeException e)
{
System.out.println(e);
throw e; //rethrow the exception
}
}
} 3
throws
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} 4
import java.io.*;
class ThrowsDemo
{
psvm(String d[])throws IOException,NumberFormatException
{
int i;
InputStreamReader is=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(in);
i=Integer.parseInt(br.readLine());
System.output.println(i);
}}

5
finally
It creates a block of code that will b 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 db
This block is optional but when included is placed after the last catch
block of a try

6
Form:
try
{}
catch(exceptiontyp try block
e e)
{}
finally finally Catch block
{}

finally

7
8
Java Exception Type Hierarchy
 Object

Throwable

Error Exception

RunTimeException
LinkageError ArithmeticException
IndexOutOfBoundsException

ThreadDeath StringIndexOutOfBoundsException

IllegalArguementException

VirtualMachineError NumberFormatException

IllegalAccessException
AWTError NoSuchMethodException
10
ClassNotFoundException
11
 Unchecked Exceptions

The types of exceptions that need not be included in a

method’s throws list are called Unchecked Exceptions.

ArithmeticException
ArrayIndexOutOfBoundsException
ClassCastException
IndexOutOfBoundsException
IllegalStateException
NullPointerException
SecurityException

12
 Unchecked Exceptions

Exception Meaning

ArithmeticException Arithmetic error, such as divide-by-zero.

ArrayIndexOutOfBoundsException Array index is out-of-bounds.
ArrayStoreException
ClassCastException
IllegalArgumentException
IllegalMonitorStateException
IllegalStateException
IllegalThreadStateException
IndexOutOfBoundsException
NegativeArraySizeException
Assignment to an array element of an
incompatible type.
Invalid cast.
Illegal argument used to invoke a method.
Illegal monitor operation, such as waiting on
an unlocked thread.
Environment or application is in incorrect
state.
Requested operation not compatible with
13
 Checked Exceptions

The types of exceptions that must be included in a method’s

throws list if that method can generate one of these
exceptions and does not handle it ,are called Checked
Exceptions.

ClassNotFoundException
CloneNotSupportedException
IllegalAccessException
InstantiationException
InterruptedException
NoSuchFieldException
NoSuchMethodException

14
 Checked Exceptions
Exception
ClassNotFoundException
CloneNotSupportedException
IllegalAccessException
InstantiationException
InterruptedException
NoSuchFieldException
NoSuchMethodException
Meaning
Class not found.
Attempt to clone an object that does not
implement the Cloneable interface.
Access to a class is denied.
Attempt to create an object of an abstract
class or interface.
One thread has been interrupted by another
thread.
A requested field does not exist.
A requested method does not exist. 15
 Java’s Built-in Exceptions: inside java.lang
package
• A checked exception is any subclass of Exception
(or Exception itself), excluding class
RuntimeException and its subclasses.
• Making an exception checked forces client
programmers to deal with the possibility that the
exception will be thrown.
• eg, IOException thrown by java.io.FileInputStream's
read() method .
• Unchecked exceptions are RuntimeException and
any of its subclasses. Class Error and its subclasses
also are unchecked.

16
• With an unchecked exception, however, the
compiler doesn't force client programmers either to
catch the exception or declare it in a throws clause.
• In fact, client programmers may not even know
that the exception could be thrown.
• eg, StringIndexOutOfBoundsException thrown by
String's charAt() method.
• Checked exceptions must be caught at
compile time. Runtime exceptions do not
need to be.

17
Creating 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);
}
18
class TestMyException
{
public static void main(String d[])
{
int x=5,y=1000;
try
{
float z=(float)x/(float)y;
if(z<0.01)
{
throw new MyException("too small number");
}
}

19
catch(MyException me)
{
System.out.println("caught my exception");
System.out.println(me.getMessage());
}
finally
{
System.out.println("from finally");
}
} Output
}
• E:\JAVAPGMS>java
TestMyException
• caught my exception
• too small number
• from finally 20
 Summary

Objective of Exception Handling

Making safer program by

providing special mechanism

21
 Thank you

22