Exception Handling

• The exception handling in java is one of the

powerful mechanism to handle the runtime
errors so that normal flow of the application can
be maintained.
• In this session, we will learn about java
exception, its type and the difference between
checked and unchecked exceptions.
What is exception?
Dictionary Meaning: Exception is an abnormal
condition.
• In java, exception is an event that disrupts the
normal flow of the program. It is an object which
is thrown at runtime.
 What is exception handling
• Exception Handling is a mechanism to handle runtime
errors such as ClassNotFound, IO, SQL, Remote etc.
Advantage of Exception Handling
• The core advantage of exception handling is to
maintain the normal flow of the application. Exception
normally disrupts the normal flow of the application
that is why we use exception handling. Let's take a
scenario:

Suppose there is 10 statements in your program and there occurs an exception

at statement 5, rest of the code will not be executed i.e. statement 6 to 10 will
not run. If we perform exception handling, rest of the statement will be
executed. That is why we use exception handling in java.
Hierarchy of Java Exception classes
 Types of Exception
There are mainly two types of exceptions:
checked and unchecked where error is
considered as unchecked exception. The sun
microsystem says there are three types of
exceptions:
• Checked Exception
• Unchecked Exception
• Error
 Difference between checked and unchecked exceptions
1) Checked Exception
• The classes that extend Throwable class except
RuntimeException and Error are known as checked exceptions
e.g.IOException, SQLException etc. Checked exceptions are
checked at compile-time.
2) Unchecked Exception
• The classes that extend RuntimeException are known as
unchecked exceptions e.g. ArithmeticException,
NullPointerException, ArrayIndexOutOfBoundsException etc.
Unchecked exceptions are not checked at compile-time rather
they are checked at runtime.
3) Error
• Error is irrecoverable e.g. OutOfMemoryError,
VirtualMachineError, AssertionError etc.
Common scenarios where exceptions may occur
There are given some scenarios where unchecked exceptions
can occur. They are as follows:
1) Scenario where ArithmeticException occurs
If we divide any number by zero, there occurs an
ArithmeticException.
int a=50/0; //ArithmeticException
2) Scenario where NullPointerException occurs
If we have null value in any variable, performing any operation
by the variable occurs an NullPointerException.
String s=null;
System.out.println(s.length()); //NullPointerException
3) Scenario where NumberFormatException occurs
The wrong formatting of any value, may occur
NumberFormatException. Suppose I have a string variable that
have characters, converting this variable into digit will occur
NumberFormatException.
String s="abc";
int i=Integer.parseInt(s); //NumberFormatException
4) Scenario where ArrayIndexOutOfBoundsException occurs
If you are inserting any value in the wrong index, it would result
ArrayIndexOutOfBoundsException as shown below:
int a[]=new int[5];
a[10]=50; //ArrayIndexOutOfBoundsException
 Java Exception Handling Keywords
There are 5 keywords used in java exception handling.
• try
• catch
• finally
• throw
• throws
 Java try-catch
• Java try block
Java try block is used to enclose the code that
might throw an exception. It must be used within
the method.
• Java try block must be followed by either catch or
finally block.
Syntax of java try-catch
try{
//code that may throw exception
}catch(Exception_class_Name ref){ }
 Syntax of try-finally block
try{
//code that may throw exception
}finally{ }
Java catch block
• Java catch block is used to handle the
Exception. It must be used after the try block
only.
• You can use multiple catch block with a single
try.
 Problem without exception handling
Let's try to understand the problem if we don't
use try-catch block.
public class Testtrycatch1{
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

As displayed in the above example, rest of the code is not executed (in such case,
rest of the code... statement is not printed).
There can be 100 lines of code after exception. So all the code after exception will
not be executed.
 Solution by exception handling
Let's see the solution of above problem by java try-catch block.
public class Testtrycatch2{
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...

Internal working of java try-catch block
 Java Multi catch block
• If you have to perform different tasks at the occurrence of
different Exceptions, use java multi catch block.
• Let's see a simple example of java multi-catch block.
public class TestMultipleCatchBlock{
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");}
System.out.println("rest of the code..."); } }
class TestMultipleCatchBlock1{
public static void main(String args[]){
try{
int a[]=new int[5];
a[5]=30/0;
}
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 completed");}
System.out.println("rest of the code...");
} Output:
} Compile-time error
Rule: At a time only one Exception is occurred and at a time only one catch
block is executed.

Rule: All catch blocks must be ordered from most specific to most general
i.e. catch for ArithmeticException must come before catch for Exception .
 Java finally block
• 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.

Note: If you don't handle exception, before terminating the program, JVM
executes finally block(if any).
 Usage of Java finally
Let's see the different cases where java finally block can be used.
Case 1
Let's see the java finally example where exception doesn't occur.

class TestFinallyBlock{
public static void main(String args[]){
try{
int data=25/5;
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...");
}
}
Case 2
Let's see the java finally example where exception occurs and not
handled.
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

Case 3
Let's see the java finally example where exception occurs and
handled.
public class TestFinallyBlock2{
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...");
} Output:
} Exception in thread main java.lang.ArithmeticException:/ by zero
finally block is always executed

rest of the code...

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

We can throw either checked or uncheked exception

in java by throw keyword.
The throw keyword is mainly used to throw custom
exception. We will see custom exceptions later.

The syntax of java throw keyword is given below.

throw exception;

Let's see the example of throw IOException.

throw new IOException("sorry device error);
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

In this example, we have created the validate method that takes integer
value as a parameter. If the age is less than 18, we are throwing the
ArithmeticException otherwise print a message welcome to vote.
 throws keyword
The Java 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.

Exception Handling is mainly used to handle the checked

exceptions. If there occurs any unchecked exception such as
NullPointerException, it is programmers fault that he is not
performing check up before the code being used.

Syntax of java throws

return_type method_name() throws exception_class_name{
//method code
}
Which exception should be declared
Ans) checked exception only, because:
unchecked Exception: under your control so correct your code.
error: beyond your control e.g. you are unable to do anything if
there occurs VirtualMachineError or StackOverflowError.

Advantage of Java throws keyword

Now Checked Exception can be propagated (forwarded in call
stack).
It provides information to the caller of the method about the
exception.