Checked vs Unchecked Exceptions

Java splits exceptions into two enforcement categories at compile time: checked exceptions, which the compiler forces you to handle or declare, and unchecked exceptions, which you may handle but are never required to. This distinction is central to writing correct Java code and to understanding why some code compiles without a try-catch while other code refuses to compile without one.

Why it matters

Java is unusual in making the compiler enforce handling of some exceptions and not others. Knowing which is which explains why some calls demand a try-catch and others do not, and guides your own design: checked for conditions a caller can reasonably recover from, unchecked for bugs that should be fixed in the code.

Checked Exceptions

A checked exception is any class that extends Exception but does not extend RuntimeException. These represent conditions that are outside a program's control but are anticipated as part of normal, correct operation — a file that might not exist, a network connection that might drop, a database that might be unreachable. IOException and SQLException are classic examples. Because the compiler checks for these at compile time, any method that can throw one must either catch it or declare it with throws.

Unchecked Exceptions

An unchecked exception extends RuntimeException (which itself extends Exception). These typically represent programming mistakes rather than external conditions — dereferencing a null reference (NullPointerException), accessing an invalid array index (ArrayIndexOutOfBoundsException), or dividing an integer by zero (ArithmeticException). The compiler does not force you to catch or declare them, on the theory that a program riddled with such errors should usually be fixed, not defensively wrapped in try-catch everywhere.

Choosing and Recognizing Which Applies

A simple test: if you can imagine a caller genuinely recovering from the failure as part of normal operation (retry the network call, ask for a different file path), it fits the checked model. If the failure signals that something in the code itself is wrong (an off-by-one bug, a missing null check), it fits the unchecked model. Errors (like OutOfMemoryError) are a separate, third category and are neither checked nor meant to be routinely caught at all.

• Checked example: IOException — must be caught or declared; represents an anticipated external failure.
• Unchecked example: NullPointerException — never required to be caught or declared; represents a programming defect.
• Unchecked example: ArrayIndexOutOfBoundsException — signals an index calculation bug rather than an external condition.

Example

import java.io.IOException;

public class CheckedUncheckedDemo {

    static void mustDeclare() throws IOException { // checked: compiler enforces this
        throw new IOException("disk unavailable");
    }

    static void noDeclarationNeeded() {
        String text = null;
        System.out.println(text.length()); // unchecked: compiles fine, fails at runtime
    }

    public static void main(String[] args) {
        try {
            mustDeclare();
        } catch (IOException e) {
            System.out.println("Checked exception handled: " + e.getMessage());
        }

        try {
            noDeclarationNeeded();
        } catch (NullPointerException e) {
            System.out.println("Unchecked exception handled: NullPointerException");
        }
    }
}

Checked exception handled: disk unavailable
Unchecked exception handled: NullPointerException

Exercise

This program does not compile, because loadConfig declares a checked exception that main ignores. Handle it in main with a try-catch so the program prints the result for both calls.

Expected output: loaded then Config missing

import java.io.FileNotFoundException;

public class ConfigLoader {

    static String loadConfig(boolean exists) throws FileNotFoundException {
        if (!exists) {
            throw new FileNotFoundException("Config missing");
        }
        return "loaded";
    }

    public static void main(String[] args) {
        System.out.println(loadConfig(true));
        System.out.println(loadConfig(false));
    }
}

import java.io.FileNotFoundException;

public class ConfigLoader {

    static String loadConfig(boolean exists) throws FileNotFoundException {
        if (!exists) {
            throw new FileNotFoundException("Config missing");
        }
        return "loaded";
    }

    public static void main(String[] args) {
        try {
            System.out.println(loadConfig(true));
            System.out.println(loadConfig(false));
        } catch (FileNotFoundException e) {
            System.out.println(e.getMessage());
        }
    }
}

Quick quiz

Interview questions