Object Oriented Programming Using Java 22MCA22

MODULE 4

EXCEPTION HANDLING
The exception hierarchy:
• An exception is an error that occurs at run time.
• In java, all exceptions are represented by classes.
• All exception class are derived from a class called Throwable.
• Throwable class is the superclass of all errors and exceptions in the Java language.
• When an exception occurs in a program, an object of some type of exception class is
generated.

Benefits of exception handling

• By using exceptions to manage errors, Java programs have the following
advantages over traditional error management techniques:
• 1: Separating Error Handling Code from
• "Regular" Code.
• 2: Propagating Errors Up the Call Stack.
• 3: Grouping Error Types and Error Differentiation.

Exception handling fundamentals

• Java exception handling is managed via five keywords.
• They are try, catch, throw, throws and finally.
• Programs statements that you want to monitor for exceptions are contained 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 in some rational manner.
• System-generated exceptions are automatically thrown by the java run-time system.
• To manually throw an exception, use the keyword throw.
• Java try block must be followed by either catch or finally block.
• In some cases, an exception that is thrown out of a method must be specified as such
by a throws clause.
• Any code that absolutely must be executed upon exiting from a try block is put in a
finally block.
Syntax of java try-catch
try {
//code that may throw exception
}
catch(Exception_class_Name ref)
{
//code to handle exception

Page 1
Object Oriented Programming Using Java 22MCA22

Syntax of try-finally block

try {
//code that may throw exception
}
finally
{

}
Ex:
Without using try-catch
public class testtry
{
public static void main(String args[]) {
int data=50/0;//may throw exception
System.out.println("rest of the code...");
}
}

Output:
• Exception in thread main java.lang.ArithmeticException:/ by zero

Using java try-catch block.

public class testtry1 {
public static void main(String args[])
{try{
int data=50/0;
}
catch(ArithmeticException e)
{System.out.println(e);
}
System.out.println("rest of the code...");
}
}

Output:
• Exception in thread main java.lang.ArithmeticException:/ by zero rest of the code...
EX:
public class testtry2 {
public static void main(String args[])
{int[] nums = new int[4];
try{ System.out.println(“RNSI
T”);
nums[7]=80;
System.out.println(“MCA”);
}
catch(ArithmeticException e)
{System.out.println(e);
}
System.out.println("rest of the code...");

Page 2
Object Oriented Programming Using Java 22MCA22

}
}
The consequences of an uncaught exception
• If your program does not catch an exception, then it will be caught by the JVM.
• The trouble is that the JVM’s default exception handler terminates execution and
displays an error message followed by a list of the methods calls that lead to the
exception.

Internal working of java try-catch block

Using multiple catch clauses

• You can associate more than one catch clause with a try. Each catch must catch a
different type of exception.
• At a time only one Exception is occurred and at a time only one catch block is
executed.
• Ex:
public class MultipleCatchBlock1 {
public static void main(String args[])
{try{
int a[]=new int[5];
a[5]=30/0;
}
catch(ArithmeticException e)
{ System.out.println("task1 is completed"); }
catch(ArrayIndexOutOfBoundsException e)
{System.out.println("task 2 completed"); }
catch(Exception e) {
System.out.println("common task completed"); }

Page 3
Object Oriented Programming Using Java 22MCA22

System.out.println("rest of the code...");

}
}
• All catch blocks must be ordered from most specific to most general
i.e. Exception class have to come at last.

class TestMultipleCatchBlock1{
public static void main(String
args[]){try{
int a[]=new int[5];
a[5]=30;
}
catch(Exception e){
System.out.println("common task completed");
}
catch(ArithmeticException
e){ System.out.println("task1 is completed");
}
catch(ArrayIndexOutOfBoundsException
e){ System.out.println("task 2 c
ompleted");
}
System.out.println("rest of the code...");
}
}
OUTPUT
Compile-time error

Catching subclass exceptions

• There is one important point about multiple catch clauses that relates to subclasses.
• A catch clause for a superclass will also match any of its subclasses.
• If you want to catch exceptions of both a superclass type and a subclass type, put the
subclass first in the catch sequence.
• if you do not, then superclass catch will also catch all derived classes.

class ExcDemo5 {
public static void main(String[] args) {
int[] numer = { 4, 8, 16, 32, 64, 128, 256, 512 };
int[] denom = { 2, 0, 4, 4, 0, 8 };
for(int i=0; i<numer.length; i++) {
try {
System.out.println(numer[i] + " / " + denom[i] + " is " +
numer[i]/denom[i]);
}catch (ArrayIndexOutOfBoundsException
exc){ System.out.println("No matching element
found.");
}
catch (Exception e){
System.out.println("Some exception occurred.");
}
}
Page 4
Object Oriented Programming Using Java 22MCA22

}
}

try blocks can be nested

• One try block can be nested within another.
• An exception generated within the inner try block that is not caught by a catch
associated with that try is propagated to the outer try block.
Syntax
try
{
statements ;
try
{
statements;
}
catch(Exception e) { }
}
catch(Exception e) { }
....

Ex:
public class Excep6 {
public static void main(String args[])
{try {
try {
int a[]=new int[5]; a[5]=30;
}
catch(Exception e) {
System.out.println("task1 is completed");
}
try {
int a[]=new int[5];
a[4]=30/0;
}
catch(ArithmeticException e)
{ System.out.println("task2 is completed");
}
int b[]=new int[5];
b[5]=30;
}
catch(Exception e) {
System.out.println("task3 is completed");
}
}
}

Page 5
Object Oriented Programming Using Java 22MCA22

Throwing an exception
• The Java throw keyword is used to explicitly throw an exception.
• we can throw either checked or unchecked exception in java by throw keyword.
• The syntax of java throw keyword is given below throw exceptob;
• Here, exceptob must be an object of an exception class derived from Throwable.
• Only object of Throwable class or its sub classes can be thrown.
Creating Instance of Throwable class
• There are two possible ways to get an instance of class Throwable,
• Using a parameter in catch block.
• Creating instance with new operator.
new NullPointerException("test");
• This constructs an instance of NullPointerException with name test.
Ex:1
public class TestThrow1 {
static void validate(int age)
{if(age<18)
throw new ArithmeticException("not valid");
else
System.out.println("welcome to vote"); }
public static void main(String
args[]){validate(13);
System.out.println("rest of the code...");
}
}

OUTPUT
Exception in thread main java.lang.ArithmeticException:not valid
Ex:2
class Test21{
static void avg()
{try {
throw new ArithmeticException("demo");
}
catch(Exception e) {
System.out.println(e);
}
}
public static void main(String args[])
{avg();
System.out.println("Exception caught");
}
}

throws
• In some cases, if a method generates an exception that it does not handle, it must declare
that exception in a throws clause.
• The general form of throws is

Page 6
Object Oriented Programming Using Java 22MCA22

return-type methName(param-list)throws except-list {

//body
}
• Here, except-list is a comma-separated list of exceptions that the method might throw
outside of itself.
• subclass of Error or RuntimeException don’t need to be specified in a throws list.

Ex:1
import java.io.*;
class rns {
void mca()throws IOException {
throw new IOException("device error");
}
}
public class Testthrows2 {
public static void main(String args[])
{try{
rns m=new rns(); m.mca();
}
catch(Exception e) {
System.out.println(e);
System.out.println("normal flow...");
}
}
}

EX:2
import java.io.*;
class rnsit{
void mca(int a) throws
IOException,ArithmeticException{if(a%2==0)
throw new IOException("device error");
else
throw new ArithmeticException("error");
}
}
class Testthrows {
public static void main(String args[])
{try{
rnsit m=new rnsit(); m.mca(2);
}
catch(Exception e){
System.out.println(e); }
System.out.println("normal flow...");
}
}
OUTPUT
java.io.IOException:device Error normal flow…

Page 7
Object Oriented Programming Using Java 22MCA22

EX3:
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);
}
}
}
Output
inside throwOne
caught java.lang.IllegalAccessException: demo

Difference between throw and throws

A close look at Throwable

• All exception types are subclasses of the built-in class Throwable.
• Throwable is at the top of the exception class hierarchy.
• 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.
• This is also the class that you will subclass to create your own custom exception
types.

Page 8
Object Oriented Programming Using Java 22MCA22

• The other branch is topped by Error, which defines exceptions that are not
expected to be caught under normal circumstances by your program.
•
Methods defined by throwable

Exception hierarchy
• The class at the top of the exception class hierarchy is the Throwable class, which is
a direct subclass of the Object class.
• Throwable has two direct subclasses –
1. Exception
2. Error

Page 9
Object Oriented Programming Using Java 22MCA22

Throwable class:
• Throwable class which is derived from Object class, is a top of exception hierarchy
from which all exception classes are derived directly or indirectly.
• It is the root of all exception classes.
• It is present in java.lang package.
Error:
• Error class is the subclass of Throwable class and a superclass of all the runtime error
classes.
• It terminates the program if there is problem-related to a system or resources (JVM).
Exception:
• It is represented by an Exception class that represents errors caused by the program
and by
• external factors.
• Exception class is a subclass of Throwable class and a superclass of all the exception
classes.
• All the exception classes are derived directly or indirectly from the Exception class.
• They originate from within the application.
•
Exception Class Hierarchy in Java

Using finally
• Java finally block is a block that is used to execute important code such as closing
connection, stream etc.
• Java finally block is always executed whether exception is handled or not.
• Java finally block must be followed by try or catch block.

Mr. Raghu Prasad K, Assistant Professor, MCA Dept | RNSIT Page 10

Object Oriented Programming Using Java 22MCA22

Syntax:
finally{
finally code
}
Ex:1
class TestFinallyBlock {
public static void main(String args[])
{try{
I nt data=25/5; 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...");
}
}
Ex:2
class TestFinallyBlock1 {
public static void main(String args[])
{try {
int data=25/0; System.out.println(data);
}
catch(NullPointerException e)
{System.out.println(e);
}
finally {
System.out.println("finally block is always executed");
}
System.out.println("rest of the code...");
}
}
• OUTPUT
(finally block is always executed)
Exception in thread main
java.lang.ArithmeticException:/ by zero
For each try block there can be zero or more catch blocks, but only one finally block.

Page 11
Object Oriented Programming Using Java 22MCA22

Difference between final, finally and finalize

Classification or Types of exceptions

• Exceptions can be categorized into two ways:
• Built-in Exceptions
o Checked Exception
o Unchecked Exception
• User-Defined Exceptions

Page 12
Object Oriented Programming Using Java 22MCA22

Built-in exceptions
• Exceptions that are already available in Java libraries are referred to as built-in
exception.
• These exceptions are able to define the error situation so that we can understand the
reason of getting this error.
• It can be categorized into two broad categories, i.e., checked exceptions and
unchecked exception.
Checked Exception
• Checked exceptions are called compiletime exceptions because these exceptions are
checked at compile-time by the compiler.
• The compiler ensures whether the programmer handles the exception or not.
• The programmer should have to handle the exception; otherwise, the system has
shown a compilation error.

Checked exceptions defined by java.lang

UnChecked Exception
• An unchecked exception is an exception that occurs at the time of execution.
• These are also called as Runtime Exceptions.
• These include programming bugs, such as logic errors or improper use of an API.
• Runtime exceptions are ignored at the time of compilation.

Page 13
Object Oriented Programming Using Java 22MCA22

Unchecked exceptions defined by java.lang

Creating Exception subclasses or how to create your own

exception
• If you are creating your own Exception that is known as custom exception or user-
defined exception.
• Just define a subclass of Exception(which is a subclass of Throwable).
• The Exception class does not define any methods of its own. It does inherit those
methods provided by Throwable.
• You can override one or more of these methods in exception subclass that you
create.
• Two commonly used Exception constructors are shown here;
Exception()
Exception(String msg)
Ex:
class MyException extends Exception
{ private int detail; MyException(int a)
{detail = a;
}
public String toString() {
return "MyException[" + detail + "]"; }
}
public class rnsitown {
static void compute(int a) throws MyException
{ System.out.println("Called compute(" + a +
")");if (a > 10)
{
throw new MyException(a);
}
System.out.println("Normal exit");

Page 14
Object Oriented Programming Using Java 22MCA22

}
public static void main(String args[]
{try {
compute(1); compute(20);
}
catch (MyException e) {
System.out.println("Caught " + e);
}
}
}
Output
Called compute(1)
Normal exit
Called compute(20)
Caught MyException[20]

• If you want to represent any object as a string, toString() method comes into existence.
• The toString() method returns the string representation of the object.

Chained Exceptions
• Chained Exceptions allows to relate one exception with another exception, i.e one
exception describes cause of another exception.
• For example, consider a situation in which a method throws an ArithmeticException
because of an attempt to divide by zero but the actual cause of exception was an I/O
error which caused the divisor to be zero.
• The method will throw only ArithmeticException to the caller.
• So the caller would not come to know about the actual cause of exception.
Chained Exception is used in such type of situations.
• Constructors Of Throwable class Which support chained exceptions in java :
• Throwable(Throwable cause) :- Where cause is the exception that causes the current
exception.
• Throwable(String msg, Throwable cause) :- Where msg is the exception message
and cause is the exception that causes the current exception.
• Methods Of Throwable class Which support chained exceptions in java :
• getCause() method :- This method returns actualcause of an exception.
• initCause(Throwable cause) method :- This method sets the cause for the calling
exception.

public class chain {

public static void main(String[] args)
{
try {
NumberFormatException ex = new
NumberFormatException("Exception");
ex.initCause(new NullPointerException("This is actual cause of the
exception"));
throw ex;
}
catch(NumberFormatException a) {

Page 15
Object Oriented Programming Using Java 22MCA22

System.out.println(a);
System.out.println(a.getCause());
}
}
}
Output
java.lang.NumberFormatException: Exception java.lang.NullPointerException: This is actual
cause of the exception

Page 16