Throws keyword in Java - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Java code using throws?

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

Java

import java.io.*;

public class TestThrows {
    static void readFile() throws IOException {
        throw new IOException("File error");
    }

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

A Compilation error: unhandled exception

B Exception in thread "main" java.io.IOException: File error

C Caught: File error

D No output

💡 Hint

Look at how the exception thrown by readFile() is handled in main.

The method readFile() declares it throws IOException. main calls readFile() inside a try block and catches IOException, printing the message. So the output is the caught message.

❓ Predict Output

intermediate

What happens if a method declares throws but caller does not handle?

What will happen when running this Java code?

Java

public class ThrowsTest {
    static void risky() throws Exception {
        throw new Exception("Risky exception");
    }

    public static void main(String[] args) {
        risky();
        System.out.println("After risky call");
    }
}

A Compilation error: unhandled exception

B Prints 'After risky call'

C Runtime exception thrown, program crashes

D No output

💡 Hint

Check if main handles or declares the exception thrown by risky().

The method risky() throws Exception. main calls risky() but does not handle or declare the exception, so compilation fails with unhandled exception error.

🔧 Debug

advanced

Identify the error in this throws usage

What error does this code produce when compiled?

Java

import java.io.IOException;

public class ThrowsDemo {
    void method() throws IOException {
        System.out.println("Inside method");
    }

    void caller() {
        method();
    }
}

A Compilation error: unhandled IOException in caller()

B Compilation error: method() must not declare throws IOException

C Runtime error: IOException thrown but not caught

D No error, compiles fine

💡 Hint

Check if caller() handles or declares the exception thrown by method().

method() declares it throws IOException, a checked exception. caller() calls method() but neither catches nor declares the exception, so compilation error occurs.

🧠 Conceptual

advanced

Which statement about throws keyword is true?

Select the correct statement about the throws keyword in Java.

A throws keyword is used to handle exceptions inside a method.

B throws keyword catches exceptions thrown by other methods.

C throws keyword can only be used with RuntimeExceptions.

D throws keyword declares that a method might throw exceptions to its caller.

💡 Hint

Think about what throws does in a method signature.

The throws keyword declares that a method might throw exceptions, passing responsibility to the caller to handle them.

❓ Predict Output

expert

What is the output of this nested throws and try-catch code?

Analyze the output of this Java program:

Java

import java.io.IOException;

public class NestedThrows {
    static void inner() throws IOException {
        throw new IOException("Inner exception");
    }

    static void outer() throws IOException {
        try {
            inner();
        } catch (IOException e) {
            System.out.println("Caught in outer: " + e.getMessage());
            throw e;
        } finally {
            System.out.println("Finally block executed");
        }
    }

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

A

Caught in outer: Inner exception
Caught in main: Inner exception

B

Caught in outer: Inner exception
Finally block executed
Caught in main: Inner exception

C

Finally block executed
Caught in main: Inner exception

D Caught in main: Inner exception

💡 Hint

Remember that finally block always runs, and exceptions rethrown propagate up.

inner() throws IOException caught in outer(), prints message, then rethrows. finally block runs printing its message. main catches rethrown exception and prints its message.