An exception is an event that disrupts the normal flow of a program's instructions during execution. Exceptions can occur for various reasons, such as invalid input, resource unavailability, or programming errors.
Exception handling is a fundamental feature that allows developers to manage and respond to exceptional conditions or errors that occur during the execution of a Java program. Java provides a robust and structured mechanism for handling exceptions.
- Hierarchy of Java Exception classes
The java.lang.Throwable class is the root class of Java Exception hierarchy inherited by two subclasses: Exception and Error.
There are mainly two types of exceptions: checked and unchecked. An error is considered as the unchecked exception. However, according to Oracle, there are three types of exceptions namely:
- Checked Exception
- Unchecked Exception
- Error
Checked Exceptions:
- Checked exceptions are exceptions that are checked by the compiler at compile time. This means that the compiler ensures that these exceptions are either caught or declared to be thrown by the method where they can occur. Examples of checked exceptions include
IOException, FileNotFoundException, ParseException, and SQLException.
Unchecked Exceptions (Runtime Exceptions):
- Unchecked exceptions, also known as runtime exceptions, are exceptions that are not checked by the compiler at compile time. Instead, they occur at runtime and are not required to be caught or declared by the method where they occur.
- Unchecked exceptions usually represent programming errors or logical errors in the code. They can occur due to incorrect use of APIs, improper data manipulation, or invalid arguments to methods. Examples of unchecked exceptions include
NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException, and IllegalArgumentException.
Error:
- Errors in Java represent serious problems that are typically beyond the control of the application. They usually indicate issues with the runtime environment or system resources.
- Examples of errors include
OutOfMemoryError, StackOverflowError, and VirtualMachineError.
Java try block is used to enclose the code that might throw an exception. It must be used within the method.
If an exception occurs at the particular statement in the try block, the rest of the block code will not execute. So, it is recommended not to keep the code in try block that will not throw an exception.
Java try block must be followed by either catch or finally block.
Java catch block is used to handle the Exception by declaring the type of exception within the parameter. The declared exception must be the parent class exception ( i.e., Exception) or the generated exception type
Java finally block is always executed whether an exception is handled or not. Therefore, it contains all the necessary statements that need to be printed regardless of the exception occurs or not.
public class ExceptionHandlingExample {
public static void main(String[] args) {
try {
int data = 50 / 0; // may throw exception
System.out.println("Result: " + data);
} catch (ArithmeticException e) {
System.err.println("Error: Division by zero is not allowed.");
} finally {
System.out.println("Cleanup code executed.");
}
}
}
A try block can be followed by one or more catch blocks. Each catch block must contain a different exception handler. So, if you have to perform different tasks at the occurrence of different exceptions, use java multi-catch block.
public class MultipleCatchBlock1 {
public static void main(String[] args) {
try {
int a[] = new int[5];
a[5] = 30/0;
} catch(ArithmeticException e) {
System.out.println("Arithmetic Exception occurs");
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("ArrayIndexOutOfBounds Exception occurs");
} catch(Exception e) {
System.out.println("Parent Exception occurs");
}
System.out.println("rest of the code");
}
}
public class MultipleExceptionExample {
public static void main(String args[]) {
try {
int array[] = new int[10];
array[10] = 30/0;
}
catch (Exception | ArithmeticException | ArrayIndexOutOfBoundsException e) {
System.out.println(e.getMessage());
}
}
}
The Java throw keyword is used to throw an exception explicitly. We can throw either checked or unchecked exceptions in Java by throw keyword.
Throwing an unchecked exception doesn't require you to declare it using the throws clause in the method signature or handle it with a try-catch block.
public class UncheckedExceptionExample {
public static void main(String[] args) {
try {
// Call a method that throws an unchecked exception
int result = divide(10, 0);
System.out.println("Result: " + result); // This line won't be reached
} catch (ArithmeticException e) {
// Catch and handle the exception
System.out.println("An arithmetic exception occurred: " + e.getMessage());
}
}
public static int divide(int dividend, int divisor) {
// Check if divisor is zero
if (divisor == 0) {
// Throw an unchecked exception
throw new ArithmeticException("Error: Division by zero");
}
// Return the result of the division
return dividend / divisor;
}
}
For checked exceptions, it is indeed required to either handle the exception using a try-catch block or declare the exception in the method signature using the throws keyword.
public class CheckedExample {
public static void main(String[] args) {
try {
// Call a method that throws a checked exception
readFile("nonexistent_file.txt");
} catch (FileNotFoundException e) {
// Catch and handle the exception
System.out.println("File not found: " + e.getMessage());
}
}
public static void readFile(String filename) throws FileNotFoundException {
// Check if file exists
File file = new File(filename);
if (!file.exists()) {
// Throw FileNotFoundException explicitly
throw new FileNotFoundException("File '" + filename + "' not found");
}
// Try to open the file
try {
FileReader reader = new FileReader(file);
// Read data from the file (this won't be executed in this example)
reader.close();
} catch (IOException e) {
// Handle the IOException if opening or reading from the file fails
System.out.println("Error reading file: " + e.getMessage());
}
}
}
The Java throws keyword is used to declare an exception. It gives an information to the programmer that there may occur an exception.
If we are calling a method that declares an exception, we must either caught or declare the exception.
There are two cases:
- Case 1: We have caught the exception i.e. we have handled the exception using try/catch block.
- Case 2: We have declared the exception i.e. specified throws keyword with the method.
import java.io.*;
class M {
void method() throws IOException {
throw new IOException("device error");
}
}
public class Testthrows2 {
public static void main(String args[]) {
try {
M m = new M();
m.method();
} catch(Exception e) {
System.out.println("exception handled");
}
System.out.println("normal flow...");
}
}
class M {
void method() {
System.out.println("device operation performed");
}
}
class Testthrows3 {
public static void main(String args[]) throws IOException { // declare exception
M m = new M();
m.method();
System.out.println("normal flow...");
}
}
There are many rules if we talk about method overriding with exception handling.
If the superclass method does not declare an exception, subclass overridden method cannot declare the checked exception.
class Parent{
// defining the method
void msg() {
System.out.println("parent method");
}
}
public class TestExceptionChild extends Parent{
// overriding the method in child class
// gives compile time error
void msg() throws IOException {
System.out.println("TestExceptionChild");
}
public static void main(String args[]) {
Parent p = new TestExceptionChild();
p.msg();
}
}
If the superclass method does not declare an exception, subclass overridden method cannot declare the checked exception but can declare unchecked exception.
class Parent{
void msg()throws ArithmeticException {
System.out.println("parent method");
}
}
public class TestExceptionChild2 extends Parent{
void msg()throws Exception {
System.out.println("child method");
}
public static void main(String args[]) {
Parent p = new TestExceptionChild2();
try {
p.msg();
}
catch (Exception e){}
}
}
If the superclass method declares an exception, subclass overridden method can declare the same subclass exception or no exception but cannot declare parent exception.
class Parent{
void msg()throws ArithmeticException {
System.out.println("parent method");
}
}
public class TestExceptionChild2 extends Parent{
void msg()throws Exception {
System.out.println("child method");
}
public static void main(String args[]) {
Parent p = new TestExceptionChild2();
try {
p.msg();
}
catch (Exception e){}
}
}
