Course contentsShow
← Java
Lesson 745 of 2,87018. Exception Handling FundamentalsFree lesson

Re-throwing Exceptions After Partial Handling

Learn how to catch an exception, perform cleanup or logging, then re-throw it to continue propagation.

Re-throwing Exceptions After Partial Handling

What you'll learn: How to catch an exception, perform some necessary work (like logging or cleanup), then throw it again so other parts of your program can handle it too.

The Core Idea

Sometimes you need to intercept an exception to do something useful—log an error message, close a resource, or update application state—but you're not ready to fully handle the exception at that point in your code. The solution is to catch the exception, do your work, then re-throw it using the throw keyword so it continues propagating up the call stack.

Think of it like a security checkpoint: you stop someone briefly to record their entry in a logbook, but then wave them through to their actual destination.

How It Works

Inside a catch block, you can use throw followed by the caught exception reference to re-throw it:

public void processFile(String filename) {
    try {
        // Code that might throw IOException
        readFile(filename);
    } catch (IOException e) {
        // Partial handling: log the error
        System.out.println("Error reading file: " + filename);
        
        // Re-throw so caller can handle too
        throw e;
    }
}

The method still needs a throws declaration because the exception propagates out:

public void processFile(String filename) throws IOException {
    try {
        readFile(filename);
    } catch (IOException e) {
        System.out.println("Logged: " + e.getMessage());
        throw e;  // Continue propagation
    }
}

When to Use This Pattern

  • Logging: Record the exception before it moves up
  • Partial cleanup: Release some resources while letting others handle the error
  • Adding context: Log additional state information before propagation

Key Takeaway: Re-throwing lets you perform partial handling (logging, cleanup) in one layer while allowing higher layers to make the final decision about exception handling.