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

Checked exceptions — compiler forces you to handle them (try/catch or declare throws). Unchecked exceptions — compiler doesn't force handling (runtime errors).

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

Checked exceptions (compile-time):

• Extend Exception (but NOT RuntimeException).
• Compiler requires you to either:
  • Catch them with try/catch, OR
  • Declare them in the method signature with throws.
• Represent recoverable errors (file not found, network failure, etc.).
• Common examples: IOException, SQLException, ClassNotFoundException, FileNotFoundException.

1// This WON'T compile without try/catch or throws:
2public void readFile(String path) throws IOException {
3    FileInputStream fis = new FileInputStream(path);
4    // Compiler insists you handle FileNotFoundException
5}
6
7// Option 1: Catch it
8public void loadConfig() {
9    try {
10        FileInputStream fis = new FileInputStream("config.txt");
11        // read config...
12    } catch (FileNotFoundException e) {
13        System.err.println("Config file not found: " + e.getMessage());
14    } catch (IOException e) {
15        System.err.println("Error reading config: " + e.getMessage());
16    }
17}
18
19// Option 2: Declare it (propagate to caller)
20public void loadConfig() throws FileNotFoundException, IOException {
21    FileInputStream fis = new FileInputStream("config.txt");
22    // read config...
23}

Unchecked exceptions (runtime):

• Extend RuntimeException (which extends Exception).
• Compiler does NOT require try/catch or throws declaration.
• Represent programming errors (bugs) — things that shouldn't happen if code is correct.
• Common examples: NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException, IllegalArgumentException, ClassCastException.

1// These compile without try/catch (but you should still handle them!):
2
3// NullPointerException
4String str = null;
5// str.length(); // Runtime: NullPointerException
6
7// ArrayIndexOutOfBoundsException
8int[] arr = new int[5];
9// arr[10] = 1; // Runtime: ArrayIndexOutOfBoundsException
10
11// ArithmeticException
12int result = 10 / 0; // Runtime: ArithmeticException: / by zero
13
14// IllegalArgumentException (should be thrown by developers)
15public void setAge(int age) {
16    if (age < 0 || age > 150) {
17        throw new IllegalArgumentException("Invalid age: " + age);
18    }
19    this.age = age;
20}
21
22// ClassCastException
23Object obj = "hello";
24// Integer num = (Integer) obj; // Runtime: ClassCastException

Exception hierarchy:

Key differences:

• Checked — compile-time enforced, must handle or declare.
• Unchecked — runtime only, compiler ignores them.
• Checked — extends Exception directly.
• Unchecked — extends RuntimeException.
• Checked — represent recoverable external errors.
• Unchecked — represent programming bugs.

Best practices:

• Always catch checked exceptions — don't just throws Exception and ignore.
• For unchecked exceptions, use try/catch for operations that might fail (null checks, array access).
• Create custom checked exceptions for recoverable application errors.
• Create custom unchecked exceptions (extend RuntimeException) for programming errors.
• Never catch Error — those are JVM-level problems (OutOfMemoryError, etc.).

Common mistake: Using checked exceptions for programming errors (like throws Exception on everything). Use unchecked exceptions (IllegalArgumentException, IllegalStateException) for things that are bugs.