Imagine a family business: the parent sets policies, and the child inherits them—but with limited freedom to adjust. In Java, methods in subclasses inherit exception rules from their parent classes. How exceptions are handled in overriding methods determines whether your code compiles or breaks.

This tutorial covers how exceptions work in method overriding and inheritance, the rules for checked vs unchecked exceptions, best practices, and real-world implications.

Purpose of Java Exception Handling

Java’s exception system provides:

Controlled recovery from failures.
Clear contracts between methods and their callers.
Predictable behavior in inheritance hierarchies.

Real-world analogy: Exception rules in inheritance are like employee contracts—children (subclasses) can’t impose stricter terms than their parents.

Errors vs Exceptions

At the root of Java’s throwable system is Throwable:

Error: Serious, unrecoverable issues like OutOfMemoryError.
Exception: Recoverable problems like IOException and SQLException.

Exception Hierarchy Overview

Throwable
 ├── Error (unrecoverable)
 │    └── OutOfMemoryError, StackOverflowError
 └── Exception
      ├── Checked (must be declared or handled)
      │    └── IOException, SQLException
      └── Unchecked (RuntimeException)
           └── NullPointerException, ArithmeticException

Rules for Exceptions in Method Overriding

1. Checked Exceptions in Overridden Methods

If a parent declares a checked exception, the child:

Can throw the same exception.
Can throw a subclass of that exception.
Cannot throw a broader or new checked exception.

class Parent {
    void read() throws IOException {}
}

class Child extends Parent {
    @Override
    void read() throws FileNotFoundException {} // valid (subclass)
}

Invalid example:

class Child extends Parent {
    @Override
    void read() throws Exception {} // ❌ broader exception not allowed
}

2. No Checked Exceptions in Parent

If the parent method doesn’t declare checked exceptions, the child:

Cannot introduce new checked exceptions.
Can throw unchecked exceptions.

class Parent {
    void process() {}
}

class Child extends Parent {
    @Override
    void process() throws RuntimeException {} // allowed
}

3. Unchecked Exceptions

Both parent and child can throw any unchecked exceptions (RuntimeException).
No compiler restrictions.

class Parent {
    void calculate() {}
}

class Child extends Parent {
    @Override
    void calculate() throws ArithmeticException {} // valid
}

4. Constructors vs Overriding

Constructors are not inherited, but rules apply similarly:

A subclass constructor must respect exceptions declared by super constructors it calls.

class Parent {
    Parent() throws IOException {}
}

class Child extends Parent {
    Child() throws FileNotFoundException {} // valid (subclass)
}

Exception Chaining with Inheritance

Subclass methods often wrap parent exceptions:

class Service {
    void execute() throws IOException {}
}

class ExtendedService extends Service {
    @Override
    void execute() {
        try {
            super.execute();
        } catch (IOException e) {
            throw new RuntimeException("Wrapped exception", e);
        }
    }
}

Real-World Scenarios

File I/O

class FileHandler {
    void open() throws IOException {}
}

class CustomFileHandler extends FileHandler {
    @Override
    void open() throws FileNotFoundException {}
}

JDBC

class Repository {
    ResultSet query() throws SQLException { return null; }
}

class UserRepository extends Repository {
    @Override
    ResultSet query() throws SQLTimeoutException { return null; }
}

REST APIs (Spring Boot)

class BaseController {
    public ResponseEntity<String> fetch() throws IOException { return null; }
}

class UserController extends BaseController {
    @Override
    public ResponseEntity<String> fetch() throws FileNotFoundException { return null; }
}

Multithreading

class Task {
    void runTask() throws InterruptedException {}
}

class ExtendedTask extends Task {
    @Override
    void runTask() throws InterruptedException {}
}

Best Practices

Keep overridden exceptions narrower for clarity.
Avoid surprising callers by throwing unexpected exceptions.
Translate low-level exceptions into domain-specific ones.
Document exception contracts clearly in overridden methods.

Anti-Patterns

Introducing broader checked exceptions in child methods.
Throwing generic Exception or Throwable.
Hiding meaningful parent exceptions.

Performance Considerations

Overriding exception rules don’t impact runtime performance.
Throwing exceptions itself is costly—avoid using them for normal flow.

📌 What's New in Java Exception Handling

Java 7+: Multi-catch, try-with-resources.
Java 8: Exception handling in lambdas and streams.
Java 9+: Stack-Walking API.
Java 14+: Helpful NullPointerException messages.
Java 21: Structured concurrency improves exception propagation across threads.

FAQ: Expert-Level Questions

Q1. Why can’t child methods declare broader checked exceptions?
To maintain substitutability—child objects should work where parents are expected.

Q2. Can unchecked exceptions be added freely?
Yes, because they’re not part of the method signature contract.

Q3. Do constructors follow the same rules?
Yes, but since constructors aren’t inherited, rules apply to explicit super calls.

Q4. What’s exception translation?
Wrapping low-level exceptions in higher-level domain exceptions.

Q5. Can abstract methods define exceptions?
Yes, subclasses must respect declared checked exceptions.

Q6. What happens if child doesn’t declare parent exceptions?
It’s valid—the method just promises not to throw them.

Q7. How do interfaces handle exceptions in overriding?
Implementations must conform to interface exception contracts.

Q8. Can overriding methods reduce checked exceptions?
Yes, narrowing exceptions is allowed.

Q9. Is throwing Exception in parent ever good practice?
No, it forces subclasses into restrictive contracts.

Q10. How does Spring Boot handle inheritance exceptions?
It maps them to HTTP responses, following overriding rules.

Conclusion and Key Takeaways

In overriding, child methods must follow strict rules for exceptions.
Checked exceptions: children may narrow, not broaden.
Unchecked exceptions: no restrictions.
Use exception translation for clarity in APIs.
Always document exception contracts to avoid surprises.

By mastering inheritance exception rules, you’ll write robust, maintainable, and predictable Java applications.

Exceptions in Method Overriding and Inheritance Rules in Java