Exception propagation in Java - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Java code with exception propagation?

Consider the following Java code. What will be printed when the main method runs?

Java

public class Test {
    public static void main(String[] args) {
        try {
            methodA();
        } catch (Exception e) {
            System.out.println("Caught in main: " + e.getMessage());
        }
    }

    static void methodA() throws Exception {
        methodB();
    }

    static void methodB() throws Exception {
        throw new Exception("Error in methodB");
    }
}

A Caught in main: null

B Exception in thread "main" java.lang.Exception: Error in methodB

C Caught in main: Error in methodB

D No output

💡 Hint

Trace how the exception thrown in methodB moves up to main and is caught there.

The exception is thrown in methodB, propagated through methodA, and caught in main's catch block, printing the message.

❓ Predict Output

intermediate

What happens if a checked exception is not declared or caught?

What error will the following Java code produce when compiled?

Java

public class Test {
    public static void main(String[] args) {
        methodA();
    }

    static void methodA() {
        methodB();
    }

    static void methodB() throws Exception {
        throw new Exception("Error");
    }
}

A Compilation error: unhandled exception Exception

B Runtime exception thrown: Exception

C Program runs and prints nothing

D Compilation error: methodB not found

💡 Hint

Checked exceptions must be declared or caught.

methodA calls methodB which throws a checked exception but does not declare or catch it, causing a compile-time error.

🔧 Debug

advanced

Why does this code cause a compilation error related to exception propagation?

Identify the cause of the compilation error in this code and select the correct explanation.

Java

public class Test {
    public static void main(String[] args) {
        try {
            methodA();
        } catch (Exception e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }

    static void methodA() {
        methodB();
    }

    static void methodB() throws Exception {
        throw new Exception("Error");
    }
}

A main does not catch the exception thrown by methodB

B methodA does not declare 'throws Exception' but calls methodB which throws Exception

C methodB does not throw any exception

D methodA catches the exception but does not rethrow it

💡 Hint

Check methodA's signature and its call to methodB.

methodA calls methodB which throws a checked exception but methodA does not declare it or catch it, causing a compile-time error.

❓ Predict Output

advanced

What is the output when multiple exceptions propagate and are caught?

What will be printed when this Java program runs?

Java

public class Test {
    public static void main(String[] args) {
        try {
            methodA();
        } catch (Exception e) {
            System.out.println("Caught in main: " + e.getMessage());
        }
    }

    static void methodA() throws Exception {
        try {
            methodB();
        } catch (NullPointerException e) {
            System.out.println("Caught in methodA: " + e.getMessage());
        }
    }

    static void methodB() throws Exception {
        throw new Exception("Error in methodB");
    }
}

A Caught in main: null

B Caught in methodA: Error in methodB

C No output

D Caught in main: Error in methodB

💡 Hint

Check which exception type is caught in methodA and which propagates to main.

methodB throws Exception which is not caught by methodA's catch for NullPointerException, so it propagates to main and is caught there.

🧠 Conceptual

expert

How many exceptions are caught and printed in this nested propagation example?

Given the code below, how many times will a message be printed to the console?

Java

public class Test {
    public static void main(String[] args) {
        try {
            methodA();
        } catch (Exception e) {
            System.out.println("Caught in main: " + e.getMessage());
        }
    }

    static void methodA() throws Exception {
        try {
            methodB();
        } catch (Exception e) {
            System.out.println("Caught in methodA: " + e.getMessage());
            throw e;
        }
    }

    static void methodB() throws Exception {
        throw new Exception("Error in methodB");
    }
}

A 2

B 1

C 3

D 0

💡 Hint

Count each catch block that prints a message during propagation.

methodB throws Exception caught in methodA which prints once, then rethrows it to main which catches and prints again, total 2 prints.