Exception Handling in Java
The exception handling in java is
a mechanism to handle the runtime errors so
that normal flow of the application can be
maintained.
What is exception
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.
Advantage of Exception
Handling
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.
statement 1;
statement 2;
statement 3;
statement 4;
statement 5;//exception occurs
statement 6;
statement 7;
statement 8;
statement 9;
statement 10;
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.
Types of Exception
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.
There are given some scenarios where
unchecked exceptions can occur. They are as
follows:
ArithmeticException
If we divide any number by zero, there occurs
an ArithmeticException.
int a=50/0;//ArithmeticException
NullPointerException
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());//NullPointerEx
ception
NumberFormatException
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
ArrayIndexOutOfBoundsException
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.
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
all the code after exception will not be executed.
public class Testtrycatch2{
public static void main(String args[]){
try{
int data=50/0;
}catch(ArithmeticException e){System.out.println(e
);}
System.out.println(“hi friends");
}
}
Exception in thread main
java.lang.ArithmeticException:/ by zero
hi friends
rest of the code is executed
Java multiple 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 co
mpleted");}
catch(ArrayIndexOutOfBoundsException e){System.out.printl
n("task 2 completed");}
catch(Exception e){System.out.println("common task complet
ed");}
System.out.println("rest of the code...");
}
}
Output:
task1 completed
rest of the code...
At a time only one Exception is occured 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 .
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 tas
k completed");}
catch(ArithmeticException e){System.out.println("t
ask1 is completed");}
catch(ArrayIndexOutOfBoundsException e){System.
out.println("task 2 completed");}
System.out.println("rest of the code...");
}
Output:
Compile-time error
Java
nested
class Excep6{
try
public static void main(String args[]){
try{
try{
System.out.println("going to divide");
int b =39/0;
}catch(ArithmeticException e){System.out.println(e);}
try{
int a[]=new int[5];
a[5]=4;
}catch(ArrayIndexOutOfBoundsException e){System.out.println(e);
}
System.out.println("other statement);
}catch(Exception e){System.out.println("handeled");}
System.out.println("normal flow..");
}
}
Java finally block
Sometimes a situation may arise where a part
of a block may cause one error and the entire
block itself may cause another error. In such
cases, exception handlers have to be nested.
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 follows try or catch block.
Finally block in java can be used to put "cleanup" code
such as closing a file, closing connection etc.
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 exe
cuted");}
System.out.println("rest of the code...");
}
}
Output:5
finally block is always executed
rest of the code...
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 exe
cuted");}
System.out.println("rest of the code...");
}
}
Output:
finally block is always executed
Exception in thread main
java.lang.ArithmeticException:/ by zero
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 execute
d");}
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...
For each try block there can be zero or more catch
blocks, but only one finally block.
The finally block will not be executed if program
exits(either by calling System.exit() or by causing
a fatal error that causes the process to abort).
Java throw exception
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;
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
Java throws keyword
The Java throws keyword is used to declare an
exception.
Syntax of java throws
return_type method_name() throws exception_class_
name{
//method code
}
import java.io.IOException;
class Testthrows1{
void m()throws IOException{
throw new IOException("device error");//checked exception
}
void n()throws IOException{
m();
}
void p(){
try{
n();
}catch(Exception e){System.out.println("exception handled");}
}
public static void main(String args[]){
Testthrows1 obj=new Testthrows1();
obj.p();
System.out.println("normal flow...");
}
}
Output:
exception handled
normal flow...
