Exception Handling in Java

Before looking at how exceptions are handled in java, it is necessary to see what an exception is.

What is Exception?

Whenever a program is written, errors are encountered. Some of these errors are displayed at compile time and they demand to be corrected for the programs to run. Some of the errors do not show up at compile time but disrupts the normal flow of execution at run time. These errors are known as Exceptions in programming. "An exception is an unwanted condition that occurs at run time and disrupts the normal flow of execution of the code." An exception can also be thought as a run time error. The program with an exception is compiled successfully but not run. Exceptions occur when the operation initiated by the programmer is not valid. Most common types of exception are:

Division by zero.
Accessing an element of an array that is out of bound.
Trying to add a value in an array of the type not defined.
Accessing an element of a string that is out of bound.
Declaring array size as negative.
Etc.

When exceptions occur in the code, a sufficient mechanism is needed to handle it; else the program will not get executed smoothly. Java provides a mechanism to handle exceptions using five keywords namely; try, catch, throw, throws and finally. "Java exception is an object that describes the occurrence of an exception in the java code."

Types of exception:

We have three types of exception in java they are:

Checked Exceptions: These exceptions are extended from the java.lang.Exception class and are handled in the body of code itself using the try and catch blocks.These exceptions occur at compile time and without handling them, the program cannot be executed further. E.g. File not found, SQL and IO exception.
Unchecked Exceptions: These exceptions are extended from the java.lang.RuntimeException class and are not essentially handled in the code. Java Virtual Machine (JVM) handles such exceptions. These exceptions occur at run time. E.g. Index out of bound, division by zero, etc.
Errors: They are the exceptions that cannot be handled in normal circumstances. They are usually created in response to catastrophic failure. E.g. Stack Overflow, out of memory error, virtual machine error, etc.

How to handle Exceptions?

The exception is handled in java by using 5 keywords:

Try
Catch
Finally
Throws
Throw

1. Try and catch

Whenever a programmer feels that a block of code can throw some exception that section of code is written under the try block and set of operations to be performed after the exception is caught, written under the catch block. The catch block catches the exception thrown by the try block. A try block should always be followed by at least one catch block. Syntax of try and catch block:

try
{
.....................
..................... // code which is expected to throw an exception.
}
catch(Exception-name e)
{
.........................
......................... // process to handle the exception.
}

Program to illustrate the use of try and catch blocks

class Excep
{
public static void main(String args[])
{
int x,y;
try
{
x=0;
y=5567/5*x;
System.out.println("Result is"+y);
}
catch (ArithmeticException e)
{
System.out.println("Division by zero exception is encountered:"+e);
}
}
}

Output:

Division by zero exception is encountered: java.lang.ArithmeticException

Illustrating the use of multiple catch blocks.

In some cases, more than one exception can be thrown by a block of code. To handle multiple exceptions being thrown, we can use multiple catch blocks.

Syntax for using multiple catch blocks:

try
{
.............
}
catch(Exception-type1 e)
{
..............
}
catch(Exception-type2 e)
{
...............
}
catch(Exception-type N e)
{
...............
}

Program to show how multiple catch blocks are used within a program

class multicatch
{
public static void main(String args[])
{
int ar[] =new int[2];
ar[0]=5;
ar[1]=10; int b=5;
try
{
int x = ar[1]/b-ar[0];
System.out.println("The result of operation is"+x);
System.out.println("8th element of array is"+ar[7]);
}
catch(ArithmeticException e)
{
System.out.println("Divide by zero exception occurred"+ae);
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Element does not exist"+e);
}
catch(Exception e)
{
System.out.println("Exception occurred"+e);
}
}

In the above program, we have caught the main Exception class in the end and its specific cases are mentioned above. This is because all the specific exceptions are defined under the main exception class and if we use it at the very first place then the other catch statements will never be executed and we will get a compile time error stating; 'second catch statement is unreachable'.

2. Finally

Finally statement is usually written after the try and catch block. No matter whether any exception is thrown in the program or not, finally block always gets executed. For this reason, we use the finally block when we want a series of steps to always get executed. It can also be used to handle the exception that is not caught by the catch statement previously, or that is thrown by the try block. Each try block should have at least one catch or finally statement.

Syntax of finally

try
{
.........
}
catch(exception-type e)
{
..........
}
finally
{
...........
}

Program to illustrate the use of finally statement

class multicatch
{
public static void main(String args[])
{
int ar[] =new int[2];
ar[0]=5;
ar[1]=10; int b=5;
try
{
int x = ar[1]/b-ar[0];
System.out.println("The result of operation is"+x);
System.out.println("8th element of array is"+ar[7]);
}
catch(ArithmeticException e)
{
System.out.println("Divide by zero exception occurred"+ae);
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Element does not exist"+e);
}
catch(Exception e)
{
System.out.println("Exception occurred"+e);
}
finally
{
int z= ar[1]/ar[0];
System.out.println("Result is"+z);
}
}
}

3. Throw

With the help of throw keyword, it is possible for the programmer to explicitly throw an exception that is not defined in the Java run time system. The syntax of throw statement is-

throw throwableInstance;

Here, throwableInstance much be an

Object of Throwable class
Subclass of Throwable class

There are two ways of obtaining a throwable object:

Using a parameter in catch clause.
Creating an object with new keyword.

When throw keyword is encountered in the code, the normal flow is disrupted. The code is inspected try block, inspected to see if it has a catch statement to handle the exception, subsequently all the try blocks are checked, if no catch block is found then the exception is handled by the default exception handler.

Code to illustrate the use of throw keyword

class NewException extends Exception
{
NewException(String txt)
{
super(txt);
}
}
class TestNewException
{
public static void main(String args[])
{
int x = 1000000, y=1;
try
{
int z = x/y;
if(z>1000)
{
throw new NewException("Result is too large then desirable");
}
}
catch(NewException e)
{
System.out.println("User defined exception caught");
System.out.ptintln(e.getMessage());
}
finally
{
System.out.println("This program was declined due to uncertain termination");
}
}
}

4. Throws

Throws keyword is used with the method declaration to let the user know that the method can throw an exception of the specified type.
Throws keyword is used when the method might throw an exception but there is no mechanism to handle the exception.

Program to illustrate the use of throws keyword

class ExcepLast
{
void divide() throws ArithmeticException
{
int a =55, b=0, c;
c = a/b;
}
public static void main(String args[])
{
try
{
divide();
}
catch(ArithmeticException e)
{
System.out.println("Exception is successfully caught"+e);
}
}
}

Difference Between Throw and Throws

Throw	Throws
Throw is used to explicitly throw an exception.	Throws is used to let the users know about the exception that might be thrown by a method.
Throw keyword is followed by an instance.	Throws keyword is followed by a class.
Throw keyword is used within a method.	Throws keyword is used with the method signature.
Multiple exceptions cannot be explicitly thrown.	Multiple exceptions can be declared.
Propagation of checked exception is not possible.	Propagation of checked exception is possible.

Difference between error and exception

Error	Exception
An error is detected at compile time.	Exception is detected at run time.
An error cannot be recovered.	Exception can be recovered.
Errors are defined under the java.lang.Error package.	Exceptions are defined under the java.lang.Exception package.
Errors cannot be handled by the program code.	Exceptions can be handled in the program code.
Errors are defined as unchecked type.	Exceptions are defined as checked as well as unchecked type.
e.g. missing semicolon, missing variable declaration, etc.	e.g. dividing an integer by zero, accessing element that is out of bound, etc.

← Prev Next →

Exception Handling in Java

What is Exception?

Types of exception:

How to handle Exceptions?

1. Try and catch

Program to illustrate the use of try and catch blocks

Illustrating the use of multiple catch blocks.

2. Finally

Program to illustrate the use of finally statement

3. Throw

Code to illustrate the use of throw keyword

4. Throws

Program to illustrate the use of throws keyword

Difference Between Throw and Throws

Difference between error and exception

Related Topics

What is new in Java 17?

Davis Staircase Problem in Java

How to open the Java control panel

Convert IP to Binary in Java

Java Math floorDiv() Method

Swapping Program in Java

Matrix Multiplication in Java

String Array in Java

Java Snippets

Producer Consumer Problem in Java Using Synchronized Block

How to add 4 Years to the Current Date in Java?

Permutation Coefficient in Java

Java Comparator Interface

XOR of Array Elements Except Itself in Java

SHA Decrypt in Java

Cyclic Barrier in Java

Java Integer highestOneBit()

Modules in Golang

Pig Latin Program in Java

Isomorphic String in Java