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...