Exception Hierarchy

Every exception and error in Java descends from a single root class: Throwable. Understanding this hierarchy explains why catch blocks match subclasses, why some exceptions must be declared and others don't, and why catching certain top-level types is considered poor practice.

Why it matters

A catch block catches the named type and every subclass of it, so the hierarchy decides which block handles which failure and in what order catch blocks must be written. It also separates the problems you should handle — exceptions — from the ones you generally cannot — errors such as running out of memory.

The Throwable Tree

Throwable sits at the top and has two direct subclasses: Exception and Error. Exception is further split by whether it extends RuntimeException or not — anything extending RuntimeException is unchecked, and everything else under Exception is checked. This gives Java exceptions a clean three-branch structure.

• Throwable — the root of everything that can be thrown or caught.
• Throwable → Error — serious, usually unrecoverable JVM-level problems (e.g. OutOfMemoryError, StackOverflowError).
• Throwable → Exception — recoverable application-level problems, split into checked and unchecked.
• Exception → RuntimeException — the unchecked branch (e.g. NullPointerException, ArithmeticException, ClassCastException).
• Exception (direct subclasses outside RuntimeException) — the checked branch (e.g. IOException, SQLException).

Why Error Should Generally Not Be Caught

Error and its subclasses represent conditions a normal application is not expected to recover from, typically involving the JVM itself running out of a critical resource or reaching an invalid internal state — running out of heap memory, or a stack that has overflowed from runaway recursion. Catching an Error and trying to "handle" it usually just delays an inevitable failure while masking the real problem, and can leave the JVM in an inconsistent state. Catching Throwable broadly is discouraged for the same reason: it silently swallows Errors alongside genuine exceptions, hiding serious problems instead of surfacing them.

Why the Hierarchy Matters for catch Blocks

Because catch blocks match by type — including any subclass — a catch block for a superclass will also catch every subclass beneath it in the tree. Catching Exception broadly will catch both checked exceptions and every RuntimeException, which is why catch ordering rules (specific before general) exist, and why overly broad catches are usually a design smell: they hide exactly which failure occurred.

Example

public class HierarchyDemo {
    public static void main(String[] args) {
        try {
            int[] data = new int[3];
            System.out.println(data[10]); // throws ArrayIndexOutOfBoundsException
        } catch (RuntimeException e) {
            // Catches it because ArrayIndexOutOfBoundsException
            // extends IndexOutOfBoundsException extends RuntimeException
            System.out.println("Caught via RuntimeException: " + e.getClass().getSimpleName());
        }

        try {
            Object obj = "text";
            Integer number = (Integer) obj; // throws ClassCastException
        } catch (Exception e) {
            System.out.println("Caught via Exception: " + e.getClass().getSimpleName());
        }
    }
}

Caught via RuntimeException: ArrayIndexOutOfBoundsException
Caught via Exception: ClassCastException

Exercise

This code does not compile: the general catch (Exception e) comes first, so the specific catch below it can never be reached. Reorder the catch blocks.

Expected output: Arithmetic problem

public class CatchOrder {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
            System.out.println(result);
        } catch (Exception e) {
            System.out.println("General problem");
        } catch (ArithmeticException e) {
            System.out.println("Arithmetic problem");
        }
    }
}

public class CatchOrder {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("Arithmetic problem");
        } catch (Exception e) {
            System.out.println("General problem");
        }
    }
}

Quick quiz

Interview questions