EXCEPTIONS HANDLING

EXCEPTIONS HANDLINGAn exception is an abnormal condition that arises in a code sequence at run time. In other words, an exception is a run-time error.

Java’s exception handling, brings run-time error management into the object oriented world.

Exception-Handling FundamentalsA Java exception is an object that describes an exceptional (that is, error) condition that has occurred in a piece of code.

When an exceptional condition arises, an object representing that exception is created and thrown in the method that caused the error.

Java exception handling is managed via five keywords: try, catch, throw, throws, and

finally.

SCENARIOImagine you’re about to board an airplane to Geneva to attend an important conference.

At the last minute, you learn that the flight has been cancelled because the pilot

isn’t feeling well. Fortunately, the airline quickly arranges for an alternative pilot,

allowing the flight to take off at its originally scheduled time. What a relief.

This example illustrates how exceptional conditions can modify the initial flow of an

action and demonstrates the need to handle those conditions appropriately. In Java,

an exceptional condition (like the illness of a pilot) can affect the normal code flow

(airline flight operation). In this context, the arrangement for an alternative pilot can

be compared to an exception handler.

Depending on the nature of the exceptional condition, you may or may not be able

to recover completely. For example, would airline management have been able to get

your flight off the ground if instead an earthquake had damaged much of the airport?

TYPES OF EXCEPTIONThere are mainly two types of exceptions: checked and unchecked where error is considered as unchecked exception.

1.Checked Exception

2.Unchecked Exception

3.Error

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.

TYPES OF EXCEPTION2)UnChecked Exception

3)Error

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.

Error is irrecoverable e.g. OutOfMemoryError, VirtualMachineError, AssertionError etc.

EXCEPTION HIERARCHY

All exception classes are subtypes of the java.lang.Exception class.

Throwable

Error Exception

IOException(CHECKED)

RuntimeException(UNCHECKED)

Object

Runtime (Checked Exception)

Checked exceptions are subject to the Catch or Specify Requirement

All exceptions are checked exceptions, except for those indicated by Error, RuntimeException, and their subclasses.

The second kind of exception is the error.

These are exceptional conditions that are external to the application, and that the application usually cannot anticipate or recover from.

SCENARIOS WHERE EXCEPTION MAY OCCUR If we divide any number by zero, there occurs an ArithmeticException.

If we have null value in any variable, performing any operation by the variable occurs an NullPointerException.

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

If you are inserting any value in the wrong index, it would result ArrayIndexOutOfBoundsException as shown below:

int a=50/0;//ArithmeticException

String s=null;System.out.println(s.length());//NullPointerException

String s="abc";int i=Integer.parseInt(s);//NumberFormatException

int a[]=new int[5];a[10]=50; //ArrayIndexOutOfBoundsException

Code without Exception Handling

A method catches an exception using a combination of the try and catch keywords. If we donot catch thrown Exception, an abnormal condition occurs and execution stops. 

Result

public class ExcepTest{ public static void main(String args[]){int a[] = new int[2]; System.out.println("Access element three :" + a[3]);System.out.println("Out of the block"); }}

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3at ExcepTest.main(ExcepTest.java:4)

HOW EXCEPTION HANDLING OCCURS

Yes No

a[3]

exception object

Is handled?

JVMPrints Exception Description

Print stacktraceTerminates program

Rest of the code is Executed

Catching Exception A method catches an exception using a combination of

the try and catch keywords. A try/catch block is placed around the code that might generate an exception, if we catch exception thrown the remaining code will also excute.

Result

import java.io.*;public class ExcepTest{ public static void main(String args[]){ try{ int a[] = new int[2]; System.out.println("Access element three :" + a[3]); }catch(ArrayIndexOutOfBoundsException e){ System.out.println("Exception thrown :" + e); } System.out.println("Out of the block"); }}

Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3

Out of the block

Multiple catch blockstry{ //Protected code}catch(Exception1 e1){ //Catch block}catch(Exception2 e2){ //Catch block}catch(Exception3 e3){ //Catch block}

try{ //Protected code}catch(Exception1 | Exception2 | Exception2 e1){ //Catch block}

In JD

K 1

.7

At a time only one Exception is occured and at a time only one catch

block is executed.

EXAMPLE OF MULTICATCH

Result

class Excep4{ 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..."); }}

task1 completedrest of the code...

MULTICATCH EXAMPLE 2 All catch blocks must be ordered from most specific to most general i.e.

catch for ArithmeticException must come before catch for Exception .

Output:Compile-time error: ArithmeticException already been caught

class Excep4{ 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..."); }}

NESTED TRY BLOCKpublic class Excep6{ 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.."); }}

finally Block

Yes

NO Yes No

Program Code

Exception Occurred

Exception Handled

Finally Block Executes

finally must be followed by try or

catch block.

For each try block there can be zero or more catch blocks, but only one finally

block.

Note: 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).

throw KEYWORD

The throw keyword is used to explictily throw an exception.

class Excep13{

static void verify (int age){ if(age<18) throw new ArithmeticException("not valid"); else System.out.println("welcome to vote"); } public static void main(String args[]){ verify(13); System.out.println("rest of the code..."); }}

Output:Exception in thread main java.lang.ArithmeticException:not valid

THROWING OWN USERDEFINED EXCEPTIONSclass InvalidAgeException extends Exception{ InvalidAgeException(String s){ super(s); }}

class Excep13{

static void validate(int age)throws InvalidAgeException{ if(age<18) throw new InvalidAgeException("not valid"); else System.out.println("welcome to vote"); } public static void main(String args[]){ try{ validate(13); }catch(Exception m){System.out.println("Exception occured: "+m);}

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

Output:Exception occured: InvalidAgeException:not valid rest of the code...

throws KEYWORD If you are calling a method that declares an exception, you

must either catch or declare the exception.

import java.io.IOException;class Simple{ 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[]){ Simple obj=new Simple(); obj.p(); System.out.println("normal flow..."); }}

CASE1: YOU HANDLE THE EXCEPTIONimport java.io.*;class M{ void method()throws IOException{ throw new IOException("device error"); }}

class Test{ public static void main(String args[]){ try{ M ob=new M(); ob.method(); }catch(Exception e){System.out.println("exception handled");}

System.out.println("normal flow..."); }}

i =i =

Output:exception handled normal flow...

CASE2: YOU DECLARE THE EXCEPTION

import java.io.*;class M{ void method()throws IOException{ System.out.println("device operation performed"); }}

class Test{ public static void main(String args[])throws IOException{//declare exception M ob=new M(); ob.method();

System.out.println("normal flow..."); }}

Output:device operation performed normal flow...

DIFFERENCE BETWEEN THROW AND THROWS:

1. throw is used to explicitly throw an exception.

2. checked exception can not be propagated without throw.

3. throw is followed by an instance.

4. throw is used within the method.

5. You cannot throw multiple exception

1. throws is used to declare an exception.

2. checked exception can be propagated with throws.

3. throws is followed by class.

4. throws is used with the method signature.

5. You can declare multiple exception e.g.public void method()throws IOException,SQLException.