Exception Handling in Java with Examples

In this article, I am going to discuss Exception Handling in Java with Examples. Whenever we
develop any application there is a chance of occurring errors in the application. As Java
developers, it is our key responsibility to handle the exception while developing an application.
At the end of this article, you will understand the following pointers in detail.

1. What is an Error?
2. Compile Time and Run time Errors
3. What is an Exception?
4. Why an exception occurs?
5. What happens when an exception is raised in the program?
6. What JVM does do when a logical mistake occurred in the program?
7. Exception Hierarchy in Java
8. What are the differences between Error and Exception?
9. Types of Exceptions in Java
10. Checked and Unchecked Exceptions in Java
11. What is exception handling in Java?
12. Why do we need Exception Handling in Java?
13. How can we handle an exception in Java?
14. Multiple catch blocks in Java
15. Can we catch all exceptions using a single catch block?
16. When should we write multiple catch blocks for a single try block?
17. How to display Exception or Runtime Error Message?

What is an Error?

An Error indicates a serious problem that a reasonable application should not try to catch.

We have the following two types of errors:

1. Compile Time Error

2. Run Time Error

Compile Time Error

Errors that occur at the time of compilation of the program are called compile-time errors.
Compile-time errors occurred because if we don’t follow the java syntaxes properly, java
programming rules properly, etc. Compile-time errors are identified by the java compiler. So in
simple words, we can say that compile-time errors occur due to a poor understanding of the
programming language. These errors can be identified by the programmer and can be rectified
before the execution of the program only. So these errors do not cause any harm to the
program execution.

Run Time Error

Errors that occur at the time of execution in the program are called runtime errors. Run-Time
Errors are also called Exceptions. Exceptions may occur because programmer logic fails or JVM
fails. Exceptions are identified by JVM.

Note: The Runtime errors are dangerous because whenever they occur in the program, the
program terminates abnormally on the same line where the error gets occurred without
executing the next line of code.

What is an Exception?

Exceptions are the run-time errors that occur during the execution of the program. The
exception will cause the abnormal termination of the program execution.

An Exception is an unwanted event that interrupts the normal flow of the program. When an
exception occurs program execution gets terminated. It is an object which is thrown at runtime.

Why an exception occurs?

These errors occurred when we enter the wrong data into a variable, try to open a file for
which there is no permission, try to connect to the database with the wrong user id and
password, the wrong implementation of logic, missing required resources, etc.

There can be several reasons that can cause a program to throw an exception.

For example: Opening a non-existing file in your program, Network connection problem, bad
input data provided by the user, etc.

Why do we need Exception?

Suppose you have coded a program to access the server. Things worked fine while you were
developing the code.
During the actual production run, the server is down. When your program tried to access it, an
exception is raised.

How to Handle Exception

So far we have seen, exception is beyond developer’s control. But blaming your code failure on
environmental issues is not a solution. You need a Robust Programming, which takes care of
exceptional situations. Such code is known as Exception Handler.

In our example, good exception handling would be, when the server is down, connect to the
backup server.
To implement this, enter your code to connect to the server (Using traditional if and else
conditions).

You will check if the server is down. If yes, write the code to connect to the backup server.

Such organization of code, using “if” and “else” loop is not effective when your code has
multiple java exceptions to handle.

class connect{

if(Server Up){

// code to connect to server

else{

// code to connect to BACKUP server

What happens when an exception is raised in the program?

Program execution is terminated abnormally. It means statements placed after exception-

causing statements are not executed but the statements placed before that exception-causing
statements are executed by JVM.

What JVM does do when a logical mistake occurred in the program?

 It creates an exception class object that is associated with that logical mistake and terminates
the current method execution by throwing this exception object by using the “throw” keyword.

So we can say an exception is an event that occurs during the execution of a program that
disrupts the normal flow of instruction execution.

Example: The below example shows program execution without exception

public class ExceptionHandlingDemo

public static void main (String[]args)

int a = 20;

int b = 10;

[Link] ("a value = " + a);

[Link] ("b value = " + b);

int c = a / b;

[Link] ("c value = " + c);

Output:

Example: The following example shows program execution with the exception

public class ExceptionHandlingDemo

public static void main (String[]args)

{

int a = 20;

int b = 0;

[Link] ("a value = " + a);

[Link] ("b value = " + b);

int c = a / b;

[Link] ("c value = " + c);

}}

Output:

Explanation of the above Program:

After printing the value of a and b, JVM terminates this program execution by throwing
ArithmeticException because the logical mistake we committed is dividing integer numbers by
integer zero.

As we know it is not possible to divide an integer number by zero. But it is possible to divide a
number with double zero (0.0).

From the above program, we can define the exception technically as

1. An exception is an event because when an exception is raised JVM internally

executes some logic to prepare that exception-related messages.

2. The exception is a signal because by looking into the exception message

developer will take necessary actions against that exception.

3. An exception is an object because for throwing an exception, JVM or we should

create an appropriate class object.
Exception Hierarchy in Java

The [Link] class is the root class of the Java Exception hierarchy which is inherited
by two subclasses:

Exception and Error.

All exception and error types are subclasses of class Throwable, which is the base class of the
hierarchy.

One branch is headed by Exception. This class is used for exceptional conditions that user
programs should catch.

NullPointerException is an example of such an exception.

Another branch, Error is used by the Java run-time system(JVM) to indicate errors having to do
with the run-time environment itself(JRE).

StackOverflowError is an example of such an error.

A hierarchy of Java Exception classes is given below:

Here,

Object: Object is the super most class of all classes available in java.

Throwable: For all types of exceptions [Link] is the superclass.

It has two main subclasses

1. Error

2. Exception

Exception: Exception is the super most class of all exceptions that may occur because of
programmer logic failure. These exceptions we can handle.
Error: Error is the super-most class of all exceptions that occur because of JVM failure. These
errors we cannot handle.

What are the differences between Error and Exception?

An Exception is an exception that can be handled. It means when an exception happens the
programmer can do something to avoid any harm. But an Error is an exception that cannot be
handled. It means it happens and the programmer cannot do anything.

Let’s see in detail

Difference 1:
Error type exception is thrown due to the problem that occurred inside JVM logic, like If there is
no memory in the java stack area to create a new Stackframe to execute method then the JVM
process is killed by throwing Error type exception “[Link]”.

If there is no memory in the heap area to create a new object then the JVM process is killed by
throwing the Error type exception “[Link]”.

Exception type exceptions are thrown due to the problem that occurred in java program logic,
like If we divide an integer number with zero, then JVM terminates program execution by
throwing Exception type exception “[Link]”.

If we pass the array size as a negative number, then JVM terminates the program execution by
throwing the exception type exception “[Link]”.

Difference 2:

We cannot catch an Error type exception because an error type exception is not thrown in our
application and once this error type exception is thrown JVM is terminated.

We can catch an Exception type exception because an exception type exception is thrown in our
program and moreover JVM is not directly terminated because of an exception type exception.
JVM is only terminated if the thrown exception is not caught.
Types of Exceptions in Java:

We have the following two types of Exceptions:

1. Checked Exceptions

2. Unchecked Exceptions