Exception Handling

Agenda

What is Exception?

 Why should we handle?

 Exception Class Hierarchy

 Types Of Exceptions

 Custom Exception
Exception

Exception is an abnormal condition in a scenario.

Reasons for Exceptions

➢A user has entered invalid data.

➢A file that needs to be opened cannot

be found.

➢A network connection has been lost in

the middle of communications or the
JVM has run out of memory
Why Should We Handle Exceptions

Advantages of Exception Handling

Stopping abnormal termination.

Separating error-Handling code from regular
business logic code.

 Propagating errors up to alert the caller.

 Grouping and differentiating error types.
Exception Types

Mainly there are 2 Types of Exceptions. They are :

 Checked Exceptions.

 Unchecked Exceptions
 Unchecked Exceptions

 The classes that extend RuntimeException are known as

unchecked exceptions.

Unchecked exceptions are not checked at compile-time rather

they are checked at runtime.

E.g. ArithmeticException, NullPointerException,

ArrayIndexOutOfBoundsException etc.
Checked Exceptions

The classes that extends Throwable class except

RuntimeException and Error
are known as checked exceptions.

These exceptions are raised when a program is working with the

external
requirement like accessing the file, accessing database tables,
assesing
remote machines etc.

Checked exceptions are checked at compile-time.

e.g.IOException, SQLException, ClassNotFoundException etc.

Exception Class Hierarchy
Error

Error is irrecoverable occurrence in a

program. We cannot handle Errors in a
Program

e.g. OutOfMemoryError, VirtualMachineError,

AssertionError etc.
Exception Handling Keywords

Exception Handling is done by using 5 keywords of

java.

 try

 catch

 finally

 throw

 throws
Try Block

try block : try block is the place where we need to

store the code which is having a chance to raise an
Exception

Syntax :
try {
Code having the possibility to raise
exception.
}
Catch block

catch block : Catch block is used to handle the

Exception.

Syntax :

catch(Exception e) // Exception is class and e is Exception

Object
{
Print statements;
}
Example

Example on combination of both try and catch :

try {
int number/0; // Code having the possibility
to raise exception.
}

catch(Exception e)
{
System.out.println("Divider number should
not be Zero");
}

Output :

Divider number should not be Zero.

Finally Block

finally block : The finally block is a block that is always

executed irrespective of the Exception raised.

Syntax :

finally
{
Exception handling statements;
}
Example

Example on finally block :

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

Output : 5
finally block is always executed
rest of the code...
Throw

throw :The throw keyword is used to explictily throw an

exception.throw key word is mainly used to inform the JVM
where an Exception is going to be rasied.

Syntax :

if(age<18)

{
throw new ArithmeticException("not valid");
}
Example

Example on throw keyword

class ExceptionDemo{

static void validateAge(int age){

if(age<18)
throw new ArithmeticException("Not Valid Age to Vote");
else
System.out.println("Valid Age to Age");
}

public static void main(String args[]){

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

Output: Exception in thread main

java.lang.ArithmeticException:not valid
Throws

throws : The throws keyword is used to declare an

exception. Handling the Esxception to calling method or
calling class

Syntax :

void method_name() throws exception_class_name

{
...
}
Example

Example on throws Keyword :

class ThrowsDemo{

void xyz()throws IOException{

throw new IOException("device error");//checked exception
}
void abc()throws IOException{
xyz();
}
void pqr(){
try{
abc();
}catch(Exception e){System.out.println("exception handled");}
}

public static void main(String args[]){

Simple obj=new Simple();
obj.pqr();
System.out.println("normal flow...");
}
}

Output:exception handled
Custom Exception

Creating our own Exception Class is called as Custom

Exception.

Our defined class should extend Exception class to create

Custom Exception Class.

Syntax :

Class InvalidAgeException extends Exception

{
....
}
Custom Exception Continue

Example on creating Custom Exception :

Class InvalidAgeException extends Exception

{
InvalidAgeException(String s)
{
super(s);
}
}
Here we have created an Exception class named
InvalidAgeException by extending Exception class.

Here super keyword plays a crucial role. Super keyword is

used to store custom Exception message in Super class i.e
Exception Class. So at the time of using the custom exception
class we can get that message from the super class
 Example
Now we use that InvalidAgeException class in our Program.

class ExceptionDemo{
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...