Java Exception Handling: Throwable Architecture & Checked vs Unchecked

In mission-critical enterprise systems, applications must handle unexpected runtime errors gracefully without abruptly crashing. Java provides a robust, object-oriented Exception Handling Framework rooted in the java.lang.Throwable class.

Figure 8: Complete Java Exception Hierarchy: Throwable branching into Error and Exception (Checked vs RuntimeException).

The Anatomy of `java.lang.Throwable`

Every exception in Java is an Object that directly or indirectly inherits from Throwable, which splits into two major branches:

1. `Error` (Fatal / System Failures)

Errors indicate catastrophic internal JVM failures or system resource exhaustion that typical applications cannot anticipate or recover from. Never catch an Error! Examples include:

OutOfMemoryError: The JVM Heap has exhausted all available RAM.
StackOverflowError: Infinite recursion has consumed the thread Call Stack.
VirtualMachineError: Internal corruption within the JVM native engine.

2. `Exception` (Recoverable Application Conditions)

Exceptions represent conditions that a well-written application can catch, log, and recover from:

Checked Exceptions (Compile-Time): Classes that extend Exception (excluding RuntimeException). The compiler forces you to handle them (e.g. IOException, SQLException, FileNotFoundException).
Unchecked Exceptions (Runtime): Classes that extend java.lang.RuntimeException. Caused by logical programming mistakes (e.g. NullPointerException, ArithmeticException, ArrayIndexOutOfBoundsException).

Checked vs. Unchecked Exceptions Comparison

Parameter	Checked Exceptions	Unchecked (RuntimeException)
Compiler Check	Verified strictly at compile-time by `javac`	Ignored at compile-time; occurs at runtime
Handling Requirement	Mandatory: Must use `try-catch` or `throws`	Optional: Best practice is to fix the underlying code bug
Inherits From	Directly from `java.lang.Exception`	Directly from `java.lang.RuntimeException`
Common Examples	`IOException`, `ClassNotFoundException`	`NullPointerException`, `ClassCastException`

University Exam Corner (BCA / B.Sc CS)

Exam Question: "State the 5 keywords used for exception handling in Java."

The 5 Exception Keywords:
1. try: Wraps guarded code that might throw an exception.
2. catch: Catches and handles a specific exception type.
3. finally: Clean-up block guaranteed to execute regardless of errors.
4. throw: Explicitly triggers an exception instance.
5. throws: Declares potential checked exceptions in a method signature.

Next Step

Now let us examine how to catch exceptions using Try, Catch, Finally, and Multi-Catch blocks. Proceed to: Java Try, Catch & Finally →

Frequently Asked Questions (FAQ)

Q1. What is an Exception in Java?

An Exception is an abnormal runtime event or error condition that disrupts the normal sequential instruction flow of a program. Java wraps error conditions inside Exception objects that can be caught and handled gracefully.

Q2. What is the key difference between Checked and Unchecked exceptions?

Checked exceptions (e.g. IOException, SQLException) are verified at compile-time by javac; the compiler forces you to handle them with try-catch or declare them with 'throws'. Unchecked exceptions (subclasses of RuntimeException, like NullPointerException) are not checked at compile-time and usually represent programming bugs.

Q3. What is the difference between an Error and an Exception?

Errors (like OutOfMemoryError, StackOverflowError) represent fatal JVM system failures from which a program cannot reasonably recover; you should never try to catch Errors. Exceptions represent recoverable application conditions that programs should catch and handle.