Java: What is the difference between checked and unchecked exceptions?

Checked — compiler enforces handling. Unchecked — runtime only, compiler doesn't force handling.

Analogy: Checked are like required safety inspections — the compiler won't let your code ship until you prove you've handled them. Unchecked are like unexpected accidents — you should prepare, but the compiler doesn't require proof.

Checked exceptions:

• Extend Exception (but NOT RuntimeException).
• Compiler requires try/catch OR throws declaration.
• Represent recoverable external errors.
• Examples: IOException, SQLException, FileNotFoundException.

1// Must handle or declare:
2public void readFile(String path) throws IOException {
3    FileInputStream fis = new FileInputStream(path);
4}
5
6// Catching:
7public void loadConfig() {
8    try {
9        FileInputStream fis = new FileInputStream("config.txt");
10    } catch (FileNotFoundException e) {
11        System.err.println("Config not found: " + e.getMessage());
12    } catch (IOException e) {
13        System.err.println("Error: " + e.getMessage());
14    }
15}

Unchecked exceptions:

• Extend RuntimeException.
• Compiler doesn't require handling.
• Represent programming errors (bugs).
• Examples: NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException.

1// These compile without try/catch:
2String str = null;
3// str.length(); // NullPointerException
4
5int[] arr = new int[5];
6// arr[10] = 1; // ArrayIndexOutOfBoundsException
7
8int result = 10 / 0; // ArithmeticException
9
10// Custom unchecked:
11public void setAge(int age) {
12    if (age < 0) throw new IllegalArgumentException("Invalid age: " + age);
13    this.age = age;
14}

Exception hierarchy:

Key differences:

• Checked — compile-time enforced. Unchecked — runtime only.
• Checked — extends Exception. Unchecked — extends RuntimeException.
• Checked — recoverable errors. Unchecked — programming bugs.

Best practices:

• Always catch checked exceptions properly.
• Use unchecked exceptions for programming errors.
• Never catch Error (JVM-level problems).
• Create custom checked exceptions for recoverable app errors.
• Create custom unchecked exceptions for programming errors.