Exception propagation in Java - Step-by-Step Execution

Concept Flow - Exception propagation

Exception occurs in method

↓

Is exception caught here?

No→Pass exception to caller

|Yes↓

Handle exception

↓

Continue normal flow

When an exception happens, Java checks if the current method handles it. If not, it passes the exception up to the caller until caught or program ends.

Execution Sample

Java

public class Test {
  static void methodA() {
    methodB();
  }
  static void methodB() {
    throw new RuntimeException("Error");
  }
  public static void main(String[] args) {
    methodA();
  }
}

This code throws an exception in methodB, which is not caught there, so it propagates up to main and stops the program.

Execution Table

Step	Method	Action	Exception State	Propagation
1	main	Calls methodA()	No exception	No
2	methodA	Calls methodB()	No exception	No
3	methodB	Throws RuntimeException	Exception thrown	No catch here, propagate up
4	methodA	No catch block	Exception propagates	Pass to caller (main)
5	main	No catch block	Exception propagates	Program terminates with error

💡 Exception not caught in any method, program stops with RuntimeException

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
exception	null	null	null	RuntimeException thrown	Uncaught exception

Key Moments - 2 Insights

Why does the exception move from methodB to methodA?

Because methodB does not have a catch block, the exception automatically moves up to the caller methodA as shown in step 3 and 4 of the execution_table.

What happens if main had a try-catch block?

If main caught the exception, the propagation would stop there and the program could handle the error gracefully, preventing termination as shown in step 5.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the exception first thrown?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Check the 'Exception State' column to see when the exception appears.

At which step does the exception propagate from methodA to main?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Look for 'Pass to caller (main)' in the 'Propagation' column.

If methodB had a try-catch block, how would the 'exception' variable change in variable_tracker?

A It would be null after step 5

B It would be RuntimeException thrown after step 3

C It would remain null after step 3

D It would be RuntimeException thrown after step 5

💡 Hint

If caught in methodB, exception does not propagate up, so variable_tracker shows no uncaught exception.

Concept Snapshot

Exception propagation in Java:
- Exception thrown in a method
- If not caught, passes to caller method
- Continues up call stack until caught or program ends
- Uncaught exceptions terminate the program
- Use try-catch to handle exceptions and stop propagation

Full Transcript

This example shows how an exception thrown in methodB moves up to methodA and then main because none catch it. The program stops with an error. Exception propagation means passing the error up the call chain until handled or program ends.

Practice

1. What does exception propagation mean in Java?

easy

A. An exception is passed up the call stack until caught or program ends

B. An exception is ignored and the program continues normally

C. An exception is automatically fixed by the JVM

D. An exception is converted into a warning message

Solution

1. Step 1: Understand exception propagation concept

   When an exception occurs, Java looks for a matching catch block in the current method. If none is found, it passes the exception to the caller method.

2. Step 2: Follow the exception up the call stack

   This passing continues up the call stack until a catch block handles it or the program terminates if uncaught.

3. Final Answer:

   An exception is passed up the call stack until caught or program ends -> Option A

4. Quick Check:

   Exception moves up call stack = A [OK]

Hint: Exception moves up call stack until caught [OK]

Common Mistakes:

• Thinking exceptions are ignored automatically
• Believing JVM fixes exceptions silently
• Confusing exceptions with warnings

2. Which of the following is the correct way to declare a method that might throw an exception?

easy

A. public void readFile() throws IOException {}

B. public void readFile() throw IOException {}

C. public void readFile() throws IOException() {}

D. public void readFile() throws-IOException {}

Solution

1. Step 1: Recall correct syntax for throws clause

   The keyword throws is used followed by the exception class name without parentheses.

2. Step 2: Check each option syntax

   public void readFile() throws IOException {} uses correct syntax: throws IOException. The other options have syntax errors.

3. Final Answer:

   public void readFile() throws IOException {} -> Option A

4. Quick Check:

   Correct throws syntax = B [OK]

Hint: Use 'throws' keyword followed by exception class name [OK]

Common Mistakes:

• Writing 'throw' instead of 'throws'
• Adding parentheses after exception name
• Using invalid symbols like '-'

3. What will be the output of the following code?

public class Test {
  static void method() throws Exception {
    throw new Exception("Error occurred");
  }
  public static void main(String[] args) {
    try {
      method();
    } catch (Exception e) {
      System.out.println(e.getMessage());
    }
  }
}

medium

A. Compilation error

B. Exception in thread "main" java.lang.Exception

C. No output

D. Error occurred

Solution

1. Step 1: Analyze method throwing exception

   The method explicitly throws a new Exception with message "Error occurred".

2. Step 2: Check exception handling in main

   The main method calls method() inside try-catch. The catch block prints the exception message.

3. Final Answer:

   Error occurred -> Option D

4. Quick Check:

   Exception caught and message printed = C [OK]

Hint: Exception message prints if caught in try-catch [OK]

Common Mistakes:

• Assuming uncaught exception causes crash
• Confusing exception message with full stack trace
• Thinking code won't compile without throws in main

4. Identify the error in this code snippet:

public class Demo {
  static void risky() {
    throw new IOException("IO error");
  }
  public static void main(String[] args) {
    risky();
  }
}

medium

A. main method must catch IOException

B. IOException cannot be thrown directly

C. Method risky() must declare 'throws IOException'

D. No error, code is correct

Solution

1. Step 1: Check exception type thrown

   IOException is a checked exception and must be declared or caught.

2. Step 2: Verify method declaration

   Method risky() throws IOException but does not declare it with 'throws' keyword, causing a compile error.

3. Final Answer:

   Method risky() must declare 'throws IOException' -> Option C

4. Quick Check:

   Checked exceptions require throws declaration = A [OK]

Hint: Checked exceptions need 'throws' or try-catch [OK]

Common Mistakes:

• Ignoring throws declaration for checked exceptions
• Thinking IOException is unchecked
• Assuming main must catch exception always

5. Consider this code:

class A {
  void process() throws Exception {
    throw new Exception("Error in A");
  }
}
class B extends A {
  @Override
  void process() throws Exception {
    super.process();
  }
}
public class Main {
  public static void main(String[] args) {
    A obj = new B();
    try {
      obj.process();
    } catch (Exception e) {
      System.out.println(e.getMessage());
    }
  }
}

What will be the output and why?

hard

A. Runtime error due to invalid override

B. Error in A, because exception propagates from superclass method

C. Compilation error due to throws mismatch

D. No output, exception is swallowed silently

Solution

1. Step 1: Understand method overriding with exceptions

   Subclass B overrides process() and calls super.process(), which throws Exception.

2. Step 2: Exception propagates to main and is caught

   Main calls obj.process() on B instance, exception thrown by A.process() propagates and is caught in main's try-catch, printing the message.

3. Final Answer:

   Error in A, because exception propagates from superclass method -> Option B

4. Quick Check:

   Exception propagates through override and caught = D [OK]

Hint: Overridden method can throw same exceptions up [OK]

Common Mistakes:

• Thinking override cannot throw exceptions declared in superclass
• Assuming exception is lost in subclass
• Confusing compile error with runtime behavior