Exception Hierarchy

#What is the Exception Hierarchy?

Every exception in Java belongs to a well-defined inheritance hierarchy. Understanding it is important because Java uses it to determine:

• Which catch block executes
• Which exceptions can be thrown
• Which exceptions must be declared
• How polymorphism works with exceptions

The root of the hierarchy is java.lang.Throwable.

#Complete Exception Hierarchy

Expanded Hierarchy

#Throwable

Everything that can be thrown must extend Throwable. Only subclasses of Throwable can be used with throw.

throw new Exception();          // Valid
throw new String("Hello");      // Compilation error

Throwable Methods

try {
    int x = 10 / 0;
} catch (Exception e) {
    System.out.println(e.getMessage());
    System.out.println(e.getCause());
    e.printStackTrace();
}

#Error

Error represents serious JVM-level problems. Usually, applications should not try to recover from them.

Examples: OutOfMemoryError, StackOverflowError, VirtualMachineError, NoClassDefFoundError, AssertionError.

public class Demo {
    public static void recursive() {
        recursive();
    }

    public static void main(String[] args) {
        recursive();
    }
}

StackOverflowError

Can We Catch Errors?

Technically, yes:

try {
    recursive();
} catch (StackOverflowError e) {
    System.out.println("Recovered");
}

#Exception

Exception represents conditions that an application can potentially recover from.

Examples: IOException, SQLException, InterruptedException, ParseException, ClassNotFoundException. Applications are expected to handle these situations appropriately.

#RuntimeException

RuntimeException is a subclass of Exception. It represents programming mistakes or invalid application state.

Examples: NullPointerException, ArithmeticException, IllegalArgumentException, IllegalStateException, ArrayIndexOutOfBoundsException, NumberFormatException, ClassCastException.

#Inheritance and Polymorphism

Inheritance Example

class AnimalException extends Exception {
}

class DogException extends AnimalException {
}

Now throw new DogException(); can be caught as any of:

catch (DogException e)
catch (AnimalException e)
catch (Exception e)
catch (Throwable e)

This is exception polymorphism.

Polymorphism with Exception References

Exception ex = new FileNotFoundException();   // Valid
Throwable t = new IOException();              // Valid
IOException ex = new Exception();             // Compilation error

A parent reference can point to a child object, but not the other way around.

#Catch Block Matching

try {
    throw new FileNotFoundException();
} catch (IOException e) {
    System.out.println("IOException");
} catch (Exception e) {
    System.out.println("Exception");
}

IOException

Why? Because FileNotFoundException → IOException → Exception, and Java picks the first compatible catch block.

Exception Matching Flow

For throw new FileNotFoundException();, Java checks the catch blocks from top to bottom:

#Catch Order

Correct — most specific first:

try {
    readFile();   // may throw FileNotFoundException / IOException
} catch (FileNotFoundException e) {
} catch (IOException e) {
} catch (Exception e) {
}

Wrong:

try {
    readFile();
} catch (Exception e) {
} catch (IOException e) {   // Compilation error
}

exception IOException has already been caught

Because Exception already catches IOException, the later block is unreachable.

#Multi-Catch (Java 7)

Instead of writing:

try {
    process();
} catch (IOException e) {
} catch (SQLException e) {
}

you can write:

try {
    process();
} catch (IOException | SQLException e) {
    System.out.println("Handled");
}

Useful when the handling logic is identical.

#Throwing Parent vs Child Exceptions

void read() throws IOException {
}

Inside this method:

• throw new FileNotFoundException(); — valid, because FileNotFoundException is a subclass of IOException.
• throw new Exception(); — invalid, because Exception is broader than IOException.

The compiler prevents this because callers are only prepared to handle IOException or its subclasses.

#Common Exception Families

#Enterprise Perspective

In enterprise applications:

• Business exceptions usually extend RuntimeException.
• Framework exceptions often wrap lower-level exceptions.
• Libraries create their own exception hierarchies.