Exception Handling

Aniket Gupta
Roll no.: 02 B.Tech CSF
PRN :190105131067
Guided By – Geeta Desai ma’am
CONTENTS
 What is an Exception ?
 Error vs Exception
 Hierarchy of Java Exception classes
 Java Exception Handling Keywords
 Types of Exception in Java
 Internal working of java try-catch block
 Exception Handler
 Java Multi Catch block
 The Throws / Throw Keywords
 The finally block
 Common scenarios where exceptions may occur
 Sequence of Events for throw
 Checked Exceptions
 Un-Checked Exceptions
 User-defined Exceptions
WHAT IS AN 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.

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.
ERROR VS EXCEPTION
Errors: An error represents a condition serious enough
that most reasonable applications should not try to
catch.
 Virtual Machine Error

 Out of memory

 Stack overflow

 Thread Death

 Linkage Error

Exceptions: An error which reasonable applications

should catch.
 Array index out of bounds

 Arithmetic errors (divide by zero)

 Null Pointer Exception

 I/O Exceptions
HIERARCHY OF JAVA EXCEPTION
CLASSES
KEYWORDS
There are 5 keywords used in java exception handling.
 Try : 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.
 Catch : Java catch block is used to handle the Exception. It
must be used after the try block only. We can use multiple
catch block with a single try.
 Finally : Executes whether or not an exception is thrown in
the corresponding try block or any of its corresponding catch
blocks.
 Throw : You can throw an exception, either a newly
instantiated one or an exception that you just caught, by
using the throw keyword.
 Throws : If a method does not handle a checked exception,
the method must declare it using the throws keyword.
TYPES OF EXCEPTION IN JAVA
 ArithmeticException
 ArrayIndexOutOfBoundsException

 ClassCastException

 IllegalArgumentException

 IndexOutOfBoundsException

 NegativeArraySizeException

 NullPointerException

 NumberFormatException

 NoSuchMethodException
INTERNAL WORKING OF JAVA
TRY-CATCH BLOCK
EXCEPTION HANDLER

Exception
“thrown”
here Thrown exception matched against
first set of exception handlers
Exception
Handler
If it fails to match, it is matched
against next set of handlers, etc.
Exception
Handler
If exception matches none of
handlers, program is abandoned
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...");
}
} At a time only one Exception is occurred and at a time only one catch
block is executed.
All catch blocks must be ordered from most specific to most general
i.e. catch for ArithmeticException must come before catch for Exception.
THE THROWS / THROW KEYWORDS
 If a method does not handle a checked exception, the
method must declare it using the throws keyword. The
throws keyword appears at the end of a method's signature.
 You can throw an exception, either a newly instantiated one
or an exception that you just caught, by using the throw
keyword.
***throws is used to postpone the handling of a checked
exception and throw is used to invoke an exception
explicitly.***

import java.io.*;
public class className
{ public void deposit(double amount) throws RemoteException
{ // Method implementation
throw new RemoteException();
}
//Remainder of class definition
}
THE FINALLY BLOCK
 The finally block follows a try block or a catch block. A finally
block of code always executes, irrespective of occurrence of
an Exception.
 Using a finally block allows you to run any cleanup-type
statements that you want to execute, no matter what
happens in the protected code.
 A finally block appears at the end of the catch blocks and has
the following syntax:

try
{ //Protected code
}catch(ExceptionType1 e1)
{ //Catch block }
catch(ExceptionType2 e2)
{ //Catch block }
finally { //The finally block always executes. }
COMMON SCENARIOS WHERE
EXCEPTIONS MAY OCCUR
 ArithmeticException occurs
int a=50/0; //ArithmeticException
 NullPointerException occurs

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

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

int a[ ]=new int[5];

a[10]=50; //ArrayIndexOutOfBoundsException
SEQUENCE OF EVENTS FOR THROW
Preceding Step

Try Block

Throw
statement

Unmatched
Catch

Matching Catch

Unmatched
Catch

Next Step
CHECKED EXCEPTIONS
 Inherit from class Exception but not from
RuntimeException
 Compiler enforces catch-or-declare

requirement
 Compiler checks each method call and

method declaration
 Checked exceptions are checked at compile-

time.
e.g. IOException, SQLException etc.
UNCHECKED EXCEPTIONS
 Inherit from class RuntimeException or class
Error
 Compiler does not check code to see if

exception caught or declared

 If an unchecked exception occurs and not

caught - Program terminates or runs with

unexpected results
 Can typically be prevented by proper coding
USER-DEFINED EXCEPTIONS:
 We can create your own exceptions in Java.
Keep the following points in mind when writing
your own exception classes.
 All exceptions must be a child of Throwable.

 If you want to write a checked exception that is

automatically enforced by the Handle or

Declare Rule, you need to extend the
Exception class.
 If you want to write a runtime exception, you

need to extend the RuntimeException class.

 We can define our own Exception class as

below:
class MyException extends Exception{ }
Thank You