What is exception handling in Java?

Exception handling in Java is a powerful mechanism to manage runtime errors and unexpected events that disrupt the normal flow of a program. It ensures that applications can gracefully recover from errors, rather than crashing abruptly, making them more robust and reliable.

What is Exception Handling?

At its core, exception handling is a process of responding to exceptions (anomalous or exceptional conditions) that occur during the execution of a program. Java provides a structured approach to deal with these situations, allowing developers to define specific actions to be taken when an error occurs, thereby preventing program termination and maintaining application stability.

Types of Exceptions

• Checked Exceptions: Exceptions that are checked at compile-time. The compiler forces the programmer to either handle them (using try-catch) or declare them (using throws). Examples: IOException, SQLException.
• Unchecked Exceptions (Runtime Exceptions): Exceptions that are not checked at compile-time. They occur during program execution and are usually caused by programming errors. Examples: NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException.
• Errors: These are irrecoverable problems that are typically outside the control of the programmer, such as OutOfMemoryError or StackOverflowError. Applications should not try to catch or handle errors.

Keywords for Exception Handling

Java provides five keywords to handle exceptions:

• try: A block of code that might throw an exception. The code within this block is monitored for exceptions.
• catch: A block of code that handles a specific type of exception. It immediately follows a try block.
• finally: A block of code that is always executed, regardless of whether an exception occurred or was caught. It's often used for cleanup operations.
• throw: Used to explicitly throw an exception from a method or any block of code.
• throws: Used in a method signature to declare that a method might throw one or more specified types of checked exceptions. It delegates the responsibility of handling the exception to the caller of the method.

How to Handle Exceptions (try-catch-finally)

The most common way to handle exceptions is by using the try-catch-finally block. The try block contains the potentially problematic code. If an exception occurs, control is transferred to the catch block that matches the exception type. The finally block ensures that certain code, like closing resources, is always executed.

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // This will throw an ArithmeticException
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Caught an ArithmeticException: " + e.getMessage());
        } finally {
            System.out.println("Finally block executed. Cleanup done.");
        }

        try {
            String text = null;
            System.out.println(text.length()); // This will throw a NullPointerException
        } catch (NullPointerException e) {
            System.out.println("Caught a NullPointerException: " + e.getMessage());
        } finally {
            System.out.println("Another finally block executed.");
        }
    }
}

The `throws` Keyword

When a method is likely to throw a checked exception, but the method itself doesn't handle it, it must declare the exception using the throws keyword in its signature. This informs calling methods that they need to either handle the exception or re-declare it.

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ThrowsExample {

    // This method declares that it might throw FileNotFoundException
    public void readFile(String filePath) throws FileNotFoundException {
        FileInputStream fis = new FileInputStream(filePath);
        System.out.println("File '" + filePath + "' opened successfully.");
        // Further processing
    }

    public static void main(String[] args) {
        ThrowsExample example = new ThrowsExample();
        try {
            example.readFile("nonexistent.txt");
        } catch (FileNotFoundException e) {
            System.out.println("Error: File not found - " + e.getMessage());
        }
    }
}

Custom Exceptions

Java allows developers to create their own custom exception classes by extending java.lang.Exception (for checked exceptions) or java.lang.RuntimeException (for unchecked exceptions). This is useful for creating domain-specific error types that make the code more readable and maintainable, clearly indicating specific issues within the application logic.