Catching and handling exceptions
In Java, we use the exception handler
components try , catch and finally blocks to handle exceptions.
To catch and handle an exception, we place the try...catch...finally block
around the code that might generate an exception. The finally block is
optional.
The syntax for try...catch...finally is:
try {
// code
} catch (ExceptionType e) {
// catch block
} finally {
// finally block
}
Java try...catch block
The code that might generate an exception is placed in the try block.
Every try block should be immediately followed by
the catch or finally block. When an exception occurs, it is caught by
the catch block that immediately follows it.
catch blocks cannot be used alone and must always be preceded by
a try block.
Example 1: try...catch blocks
class Main {
public static void main(String[] args) {
try {
int divideByZero = 5 / 0;
System.out.println("Rest of code in try block");
} catch (ArithmeticException e) {
System.out.println("ArithmeticException => " + e.getMessage());
}
}
}
Output
ArithmeticException => / by zero
In the example,
We have divided a number by 0 inside the try block. This produces
an ArithmeticException .
When the exception occurs, the program skips the rest of the code in
the try block.
Here, we have created a catch block to handle ArithmeticException .
Hence, the statements inside the catch block are executed.
If none of the statements in the try block generates an exception,
the catch block is skipped.
Multiple Catch blocks
For each try block, there can be zero or more catch blocks.
The argument type of each catch block indicates the type of exception that
can be handled by it. Multiple catch blocks allow us to handle each
exception differently.
Example 2: Multiple catch blocks
class ListOfNumbers {
public int[] arrayOfNumbers = new int[10];
public void writeList() {
try {
arrayOfNumbers[10] = 11;
} catch (NumberFormatException e1) {
System.out.println("NumberFormatException => " + e1.getMessage());
} catch (IndexOutOfBoundsException e2) {
System.out.println("IndexOutOfBoundsException => " + e2.getMessage());
}
}
}
class Main {
public static void main(String[] args) {
ListOfNumbers list = new ListOfNumbers();
list.writeList();
}
}
Output
IndexOutOfBoundsException => Index 10 out of bounds for length 10
In this example, we have declared an array of integers arrayOfNumbers of
size 10.
We know that an array index always starts from 0. So, when we try to
assign a value to index 10, an IndexOutOfBoundsException occurs because the
array bounds for arrayOfNumbers is 0 to 9.
When an exception occurs in the try block,
The exception is thrown to the first catch block. The first catch block
does not handle an IndexOutOfBoundsException , so it is passed to the
next catch block.
The second catch block in the above example is the appropriate
exception handler because it handles an IndexOutOfBoundsException . Hence,
it is executed.
Java finally block
For each try block, there can be only one finally block.
The finally block is optional. However, if defined, it is always executed
(even if the exception doesn't occur).
If an exception occurs, it is executed after the try...catch block. If no
exception occurs, it is executed after the try block.
The basic syntax of finally block is:
try {
//code
} catch (ExceptionType1 e1) {
// catch block
} catch (ExceptionType1 e2) {
// catch block
} finally {
// finally block always executes
}
Example 3: finally block
class Main {
public static void main(String[] args) {
try {
int divideByZero = 5 / 0;
} catch (ArithmeticException e) {
System.out.println("ArithmeticException => " + e.getMessage());
} finally {
System.out.println("Finally block is always executed");
}
}
}
Output
ArithmeticException => / by zero
Finally block is always executed
In this example, we have divided a number by 0. This throws
an ArithmeticException which is caught by the catch block. The finally block
always executes.
Having a finally block is considered a good practice. It is because it
includes important cleanup code such as:
code that might have been accidentally skipped
by return , continue or break statements
closing a file or connection
