Java Exception Class Hierarchy Explained

Direct Answer

Throwable is the root type for objects Java can throw and catch. Its two direct subclasses are Error and Exception. RuntimeException is an unchecked branch under Exception; other Exception subclasses are checked unless another language rule applies. Error represents serious conditions an ordinary application usually should not try to recover from, but not every Error means the JVM itself is corrupted.

Code Example

import java.io.IOException;
import java.nio.file.*;

public class HierarchyDemo {
    // IOException is checked -> must be declared with throws
    void readConfig(String path) throws IOException {
        Files.readString(Path.of(path));
    }

    void run() {
        try {
            readConfig("app.properties");      // checked
            int x = 10 / 0;                      // ArithmeticException (unchecked)
        } catch (IOException e) {                // Exception subclass
            System.err.println("File problem: " + e.getMessage());
        } catch (ArithmeticException e) {        // RuntimeException subclass
            System.err.println("Math problem: " + e.getMessage());
        }
        // OutOfMemoryError extends Error -> we deliberately never catch it
    }
}

Both branches descend from Throwable, but only the checked IOException forced the throws declaration.

Common Mistakes & Pitfalls

• Calling Exception the root: Throwable is the root; Exception and Error are sibling branches.
• Reading runtime as timing: every thrown exception occurs during execution; RuntimeException identifies the unchecked hierarchy branch.
• Equating checked with recoverable: the compiler category does not decide what this caller can recover from.
• Catching Throwable just to be safe: this also catches serious Error values the code may not be able to handle.
• Calling every Error a broken JVM: ordinary code usually lets Errors propagate, but the exact condition still matters.