Throwable, Exception, and Error classes

By / 18 May 2025 / 3 minutes of reading

Throwable, Exception, and Error Classes in Java

In Java, exception handling is based on the hierarchy of classes that represent different types of exceptions and errors. The root of this hierarchy is the Throwable class, which is a superclass for all exceptions and errors. Understanding the structure and significance of Throwable, Exception, and Error classes is essential for effective exception handling in Java.

1. Throwable Class

The Throwable class is the root class for all error and exception classes in Java. It is a subclass of Object and provides several methods for handling exceptions. It has two primary subclasses:

  • Exception
  • Error

Key Methods of Throwable:

  • getMessage() – Returns a description of the exception.
  • printStackTrace() – Prints the stack trace of the exception.
  • toString() – Returns the string representation of the exception.
public class ThrowableExample {
    public static void main(String[] args) {
        try {
            throw new Throwable("This is a Throwable example.");
        } catch (Throwable t) {
            System.out.println("Caught: " + t);
            t.printStackTrace();
        }
    }
}

2. Exception Class

The Exception class represents conditions that a program might want to catch and handle. It is further divided into:

  • Checked Exceptions: Exceptions that must be declared in the method signature using throws or handled using try-catch blocks. Example: IOException, SQLException.
  • Unchecked Exceptions: Exceptions that are not checked at compile time. They are subclasses of RuntimeException. Example: NullPointerException, ArrayIndexOutOfBoundsException.
Example of Checked Exception:
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class CheckedExceptionExample {
    public static void main(String[] args) {
        try {
            File file = new File("non_existent_file.txt");
            FileInputStream fis = new FileInputStream(file);
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        }
    }
}
Example of Unchecked Exception:
public class UncheckedExceptionExample {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]); // ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Exception: " + e);
        }
    }
}

3. Error Class

The Error class represents severe problems that are typically beyond the control of the application and should not be caught. Examples include:

  • OutOfMemoryError
  • StackOverflowError
  • VirtualMachineError

Errors are unchecked and usually indicate serious issues that the JVM cannot recover from.

Example of Error:
public class ErrorExample {
    public static void recursiveMethod() {
        recursiveMethod(); // Causes StackOverflowError
    }

    public static void main(String[] args) {
        try {
            recursiveMethod();
        } catch (StackOverflowError e) {
            System.out.println("Error: " + e);
        }
    }
}

Throwable class Methods

Understanding the hierarchy of Throwable, Exception, and Error classes is essential for effective exception handling in Java. Throwable serves as the root class, encapsulating all error and exception types. Exception represents recoverable issues that can be managed through try-catch blocks, while Error signifies serious problems that typically indicate system-level failures, making them unsuitable for handling through standard exception handling mechanisms. Proper utilization of these classes enables developers to build robust, error-resilient Java applications.

Related Posts

Scroll to Top