Java Language - 23 - Checked vs. Unchecked Exceptions

Exception Handling – Checked vs. Unchecked Exceptions

Introduction

Exception handling is a crucial part of Java programming that allows you to gracefully manage errors and exceptional conditions that may arise during the execution of your code. Java exceptions are categorized into two main types: checked exceptions and unchecked exceptions. In this guide, we’ll explore the differences between these two types of exceptions and how to handle them effectively in your Java applications.

What Are Exceptions?

Exceptions in Java are objects that represent abnormal or erroneous conditions that can occur during program execution. They are used to handle various types of errors, such as I/O errors, arithmetic errors, and network issues. Java exceptions help ensure that your programs can recover from errors and continue executing in a controlled manner.

Checked Exceptions

Checked exceptions are exceptions that are checked at compile-time. This means that when you write code that could throw a checked exception, the Java compiler ensures that you handle the exception either by catching it or declaring it in the method’s throws clause. Common checked exceptions include I/O exceptions and SQL exceptions.

Example – Handling a Checked Exception

Let’s consider an example where we read data from a file using Java’s ‘FileReader.’ The ‘FileReader’ constructor can throw a checked exception called ‘FileNotFoundException.’ We need to handle this exception using a ‘try-catch’ block.


import java.io.FileReader;
import java.io.FileNotFoundException;
import java.io.IOException;

public class CheckedExceptionExample {
    public static void main(String[] args) {
        try {
            FileReader fileReader = new FileReader("nonexistentfile.txt");
            // Read data from the file
            fileReader.close();
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("An I/O error occurred: " + e.getMessage());
        }
    }
}

In this example, ‘FileNotFoundException’ is a checked exception, and we handle it by catching it in a ‘try-catch’ block. The code ensures that the ‘FileReader’ is properly closed, even if an exception occurs.

Unchecked Exceptions (RuntimeExceptions)

Unchecked exceptions, also known as runtime exceptions, are not checked at compile time. These exceptions usually indicate programming errors or conditions that are not expected to occur during normal program execution. Common unchecked exceptions include ‘NullPointerException’ and ‘ArrayIndexOutOfBoundsException.’

Example – Unchecked Exception

Let’s take an example where we attempt to divide a number by zero, which results in an ‘ArithmeticException.’ This exception is unchecked, and it doesn’t need to be declared or caught at compile time.


public class UncheckedExceptionExample {
    public static void main(String[] args) {
        int numerator = 10;
        int denominator = 0;
        int result = numerator / denominator;
        System.out.println("Result: " + result);
    }
}

In this code, we encounter an ‘ArithmeticException’ at runtime because dividing by zero is not a valid operation. Unchecked exceptions like this are typically not caught or declared explicitly but should be handled in your code to prevent application crashes.

Differences Between Checked and Unchecked Exceptions

There are several key differences between checked and unchecked exceptions:

Checked Exceptions:
- Checked at compile time.
- Indicate external factors beyond the programmer’s control (e.g., file not found).
- Must be explicitly declared using ‘throws’ or caught using ‘try-catch.’
Unchecked Exceptions (Runtime Exceptions):
- Not checked at compile time.
- Indicate programming errors or unexpected conditions.
- Generally not explicitly declared or caught but should be handled in code.

When to Use Checked vs. Unchecked Exceptions

The choice between using checked and unchecked exceptions depends on the type of error and how you want to handle it:

Use Checked Exceptions When:
- You expect exceptional conditions that might occur and can be recovered from (e.g., file I/O errors).
- You want to force the calling code to handle or declare the exception.
Use Unchecked Exceptions When:
- The exception represents a programming error or a condition that should not occur in normal operation (e.g., dividing by zero).
- You want to handle exceptions more flexibly and not burden the caller with handling or declaring them.

Conclusion

Exception handling is a fundamental part of Java programming. Understanding the distinction between checked and unchecked exceptions is essential for writing reliable and robust code. By choosing the right type of exception for your specific use case, you can create more resilient and error-tolerant Java applications.

Java Language – 23 – Checked vs. Unchecked Exceptions