• When Errors Occur: In any program, unexpected errors, called exceptions, can occur during runtime (e.g., trying to divide by zero, opening a non-existent file).
• Exception Handling:  Java provides a structured way to deal with these exceptions using the try-catch mechanism. This prevents programs from crashing abruptly and allows for graceful error recovery.
• Exception Bubbling:  When an exception occurs within a method, Java will look for a matching catch block to handle it. If no catch block is found, the exception is propagated up the call stack – passed back to the method that called the current one, and so on. This process continues until either:
  • Matching catch Block Found: The exception is handled and execution resumes.
  • End of Call Stack: The exception reaches the main program entry point and no catch is found, usually causing your program to terminate with an error message.

Illustrative Example

Consider the example below:

Java

public class ExceptionBubblingExample {

    public static void main(String[] args) {

        System.out.println(“Main Entry”);

        funX();

        System.out.println(“Main Exit – This might not print!”);

    }

    static void funX() {

        System.out.println(“funX: Start”);

        try {

            funY();

        } catch (Exception ex) { // Catches a generic Exception

            System.out.println(“funX: Caught Exception: ” + ex.getMessage());

        }

        System.out.println(“funX: End”);

    }

    static void funY() {

        System.out.println(“funY: Start”);

        funZ();

        System.out.println(“funY: End”); 

    }

    static void funZ() {

        System.out.println(“funZ: Start”);

        int result = 10 / 0; // This will cause an ArithmeticException

        System.out.println(“funZ: End (This won’t print)”); 

    }

}

Explanation

1. main Method: Program’s entry point, calls funX.
2. funX: Starts execution, has a try-catch block with a generic Exception catch.
3. funY:  Called by funX, but has no error handling.
4. funZ: Called by funY, and causes an ArithmeticException by dividing by zero. Exception occurs here!

Bubbling Process

• funZ doesn’t handle the exception, so it bubbles up to funY.
• funY also has no try-catch, so the exception bubbles further up to funX.
• funX has a try-catch block that catches the ArithmeticException (all exceptions inherit from the base Exception class), prints a message, and continues execution.

Key Takeaways

• Purpose: Exception bubbling provides a way to centralize exception handling higher up the call stack if necessary.
  • Best Practices:Catch specific exceptions for more targeted handling.
  • When re-throwing exceptions, consider providing additional context.
  • Design your methods for robustness, so they either handle likely exceptions internally or declare the exceptions they might throw using the throws keyword.