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