Member Avatar for cakka

Hello,

I got this question from my quiz :

Consider the following code (assume that comments are replaced with real code that works as specified):

public class TestExceptions {

    static void e() {
      // Might cause any of the following unchecked exceptions to be
      // thrown:
      // Ex1, Ex2, Ex3, Ex4
    }

    static void April() {
      try {
          e();
      } catch (Ex1 ex) {
          System.out.println("April caught Ex1");
      }
    }

    static void March() {
      try {
          April();
      } catch (Ex2 ex) {
          System.out.println("March caught Ex2");
          // now cause exception Ex1 to be thrown
      }
    }

    static void February() {
      try {
          March();
      } catch (Ex1 ex) {
          System.out.println("February caught Ex1");
      } catch (Ex3 ex) {
          System.out.println("February caught Ex3");
      }
    }

    static void a() {
      try {
          February();
      } catch (Ex4 ex) {
          System.out.println("January caught Ex4");
          // now cause exception Ex1 to be thrown
      } catch (Ex1 ex) {
          System.out.println("January caught Ex1");
      }
    }

    public static void main(String[] args) {
        January();
    }
}

Assume now that this program is run four times. The first time, method e throws exception Ex1, the second time, it throws exception Ex2, etc.
What are the results of the four runs (a or b)?

And the answer is :

The program prints:
April caught Ex1
The program prints:
March caught Ex2
February caught Ex1
The program prints:
February caught Ex3
The program prints:
January caught Ex4
And execution stops due to an uncaught exception Ex1 thrown in main()

Can somebody tell me the explanation about this ?

Thank you

Edited by cakka
  • 2 Contributors
  • 1 Reply
  • 328 Views
  • 56 Minutes Discussion Span
  • Latest Post Latest Post by JamesCherrill

Dani AI

Generated

Short, practical clarification for (and building on 's point): the behavior follows normal stack-unwinding rules. When e() throws, the JVM walks back up the call stack until it finds the first catch whose parameter type matches the thrown exception. If a catch block handles the exception and does not rethrow, execution continues normally; if a catch block throws a new exception (or rethrows), that new exception continues propagating from that point.

Note: the posted code has a small naming mismatch — main calls January() but the defined method is a(). Treat a() as January() for reasoning below.

How the four runs differ (conceptual steps, not verbatim outputs):

  • If e() throws Ex1, the nearest handler is in April, so that catch runs and the exception stops there; nothing else higher in the stack sees Ex1.
  • If e() throws Ex2, April has no Ex2 handler so the exception goes to March; March's catch(Ex2) runs and, per the comment, throws an Ex1. That new Ex1 propagates up and is handled by February's catch(Ex1).
  • If e() throws Ex3, it skips April and March and is caught by February's catch(Ex3).
  • If e() throws Ex4, only January has a catch(Ex4). That catch runs and (per the comment) throws Ex1. Since nothing above January() catches Ex1 (main does not), the program terminates with an uncaught Ex1 and a stack trace.

Small concrete patterns for producing the rethrows:

catch (Ex2 ex) {
    System.out.println("March caught Ex2");
    throw new Ex1();          // throw a fresh Ex1
}

or to preserve an original as a cause (if Ex1 supports it):

catch (Ex4 ex) {
    System.out.println("January caught Ex4");
    throw new Ex1(ex);        // chain the cause so the stack shows both
}

Key takeaway: matching is done at runtime on the call stack, and throwing inside a catch behaves just like any other throw — it resumes propagation from where it was thrown.

Member Avatar for JamesCherrill

All you need to know is: it's optional to catch an unchecked exception; if you do catch it you execute whatever is in the catch block; if you don't catch it it is thrown back up to the method that called the current method. eg

When april calls e
   if e throws an exception it will be thrown back up to april because e does not catch it.
   if april gets an E1 it prints "April caught Ex1", all other exceptions are thrown back up to february.
   (etc)

That's all you ned to know to trace through all four cases yourself.

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.