Handling Exceptions practice questions

A developer is writing a method that reads a file and processes its content. The method must ensure that if an IOException occurs during reading, the method throws a custom ApplicationException that wraps the original IOException, and that any resources opened are closed properly. Which approach correctly implements this requirement?

Trap 1: try { ..

Does not rethrow the exception; it only prints it.

Trap 2: catch (Exception e) { throw new ApplicationException(e); } finally…

Catches Exception too broadly, not specific to IOException.

Trap 3: try { ..

Resource may not be closed if an exception occurs before close().

A
try { ... } catch (IOException e) { System.err.println(e); } finally { reader.close(); }
Why wrong: Does not rethrow the exception; it only prints it.
B
catch (Exception e) { throw new ApplicationException(e); } finally { reader.close(); }
Why wrong: Catches Exception too broadly, not specific to IOException.
C
try (BufferedReader reader = Files.newBufferedReader(path)) { ... } catch (IOException e) { throw new ApplicationException(e); }
Uses try-with-resources for automatic closure and wraps only IOException.
D
try { ... reader.close(); } catch (IOException e) { throw new ApplicationException(e); }
Why wrong: Resource may not be closed if an exception occurs before close().

Question 2easymultiple choice

A team is designing a logging framework. The framework's core method log(String message) may throw a checked LogException if the logging system fails. The team wants to allow callers to choose whether to handle the exception or declare it as thrown. Which declaration of the log method satisfies this requirement?

Trap 1: public void log(String message) { ..

Cannot throw checked exception without declaration.

Trap 2: public void log(String message) throws Error { ..

Error is for serious JVM issues, not appropriate.

Trap 3: public void log(String message) throws RuntimeException { ..

RuntimeException is unchecked; callers are not forced to handle.

A
public void log(String message) throws LogException { ... }
Checked exception forces caller to handle or declare.
B
public void log(String message) { ... }
Why wrong: Cannot throw checked exception without declaration.
C
public void log(String message) throws Error { ... }
Why wrong: Error is for serious JVM issues, not appropriate.
D
public void log(String message) throws RuntimeException { ... }
Why wrong: RuntimeException is unchecked; callers are not forced to handle.

Question 3hardmulti select

Which TWO statements about the try-with-resources statement are correct? (Choose two.)

Trap 1: The resource variable must be declared as final.

It is effectively final, but explicit final is optional.

Trap 2: A try-with-resources statement cannot have a finally block.

It can have a finally block.

Trap 3: Resources are closed before the try block executes.

They are closed after the try block completes.

A
The resource class must implement AutoCloseable.
Correct: only AutoCloseable resources are allowed.
B
The resource variable must be declared as final.
Why wrong: It is effectively final, but explicit final is optional.
C
Resources are closed in the reverse order of their declaration.
Correct: resources are closed in reverse order.
D
A try-with-resources statement cannot have a finally block.
Why wrong: It can have a finally block.
E
Resources are closed before the try block executes.
Why wrong: They are closed after the try block completes.

Question 4mediummultiple choice

What is the result when the main method is executed?

Exhibit

Refer to the exhibit.

```
public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            throw new RuntimeException("A");
        } catch (RuntimeException e) {
            throw new RuntimeException("B");
        } finally {
            throw new RuntimeException("C");
        }
    }
}
```

Trap 1: Both B and C are printed and the program terminates.

Only one exception propagates; the other is suppressed.

Trap 2: B is printed and the program terminates.

The finally block throws after catch, so B is not the final thrown exception.

Trap 3: A is printed and the program terminates.

The exception from try is caught, not printed.

A
Both B and C are printed and the program terminates.
Why wrong: Only one exception propagates; the other is suppressed.
B
B is printed and the program terminates.
Why wrong: The finally block throws after catch, so B is not the final thrown exception.
C
C is printed and the program terminates.
Finally block's exception replaces the catch block's exception.
D
A is printed and the program terminates.
Why wrong: The exception from try is caught, not printed.

Question 5hardmultiple choice

You are responsible for a Java 17 application that processes user uploads. The application uses a custom AutoCloseable resource, UploadSession, which must always be closed after use to free server resources. A junior developer wrote the following code:

``` UploadSession session = new UploadSession(); try { session.upload(data); // more processing

} catch (UploadException e) {

log.error("Upload failed", e);

} finally {

session.close();

```

During a code review, you notice that the close() method of UploadSession throws a checked CloseException. The current code does not handle this exception. Which course of action should you recommend to ensure the application is robust and follows best practices?

Trap 1: Add a try-catch block inside the finally block to handle…

Verbose and does not use the automatic suppression mechanism.

Trap 2: Declare the method with throws CloseException, and remove the…

Pushes the problem to the caller without guaranteeing closure on all paths.

Trap 3: Keep the code as-is

Ignoring exceptions is bad practice and can cause resource leaks.

A
Add a try-catch block inside the finally block to handle CloseException from session.close().
Why wrong: Verbose and does not use the automatic suppression mechanism.
B
Declare the method with throws CloseException, and remove the finally block.
Why wrong: Pushes the problem to the caller without guaranteeing closure on all paths.
C
Keep the code as-is. The CloseException is not critical; it can be ignored.
Why wrong: Ignoring exceptions is bad practice and can cause resource leaks.
D
Rewrite the code to use try-with-resources: try (UploadSession session = new UploadSession()) { ... } catch (UploadException e) { ... }
Try-with-resources handles closure automatically and properly suppresses exceptions.

Question 6mediummulti select

Which TWO of the following are checked exceptions in Java?

Trap 1: ArithmeticException

ArithmeticException is an unchecked exception.

Trap 2: ArrayIndexOutOfBoundsException

ArrayIndexOutOfBoundsException is an unchecked exception.

Trap 3: NullPointerException

NullPointerException is an unchecked exception.

A
SQLException
SQLException is a checked exception.
B
ArithmeticException
Why wrong: ArithmeticException is an unchecked exception.
C
ArrayIndexOutOfBoundsException
Why wrong: ArrayIndexOutOfBoundsException is an unchecked exception.
D
NullPointerException
Why wrong: NullPointerException is an unchecked exception.
E
IOException
IOException is a checked exception.

Question 7hardmultiple choice

Given the stack trace, which statement is true about the exception handling?

Exhibit

Refer to the exhibit.
```
Exception in thread "main" java.lang.RuntimeException: Error processing order
    at com.example.OrderService.process(OrderService.java:25)
    at com.example.OrderService.main(OrderService.java:10)
Caused by: java.sql.SQLException: Connection timeout
    at com.example.db.DatabaseConnection.connect(DatabaseConnection.java:15)
    at com.example.OrderService.process(OrderService.java:22)
    ... 1 more
```

Trap 1: Both exceptions are checked, and the code must handle both.

Only SQLException is checked; RuntimeException is unchecked.

Trap 2: The RuntimeException is caused by a checked exception, so it must…

RuntimeException is unchecked; it does not need to be declared. The cause being checked does not require declaration of the wrapper.

Trap 3: The RuntimeException is an unchecked exception, so it cannot be…

Unchecked exceptions can be caught; they are not required to be handled but can be.

A
Both exceptions are checked, and the code must handle both.
Why wrong: Only SQLException is checked; RuntimeException is unchecked.
B
The RuntimeException is caused by a checked exception, so it must be declared in the throws clause.
Why wrong: RuntimeException is unchecked; it does not need to be declared. The cause being checked does not require declaration of the wrapper.
C
The SQLException is a checked exception, and the code must handle it or declare it.
SQLException is checked and must be handled or declared.
D
The RuntimeException is an unchecked exception, so it cannot be caught.
Why wrong: Unchecked exceptions can be caught; they are not required to be handled but can be.

Question 8easymultiple choice

You are developing a microservice that processes financial transactions. The service reads transaction data from a message queue, validates it, and writes results to a database. The code uses a try-with-resources statement to manage database connections. During testing, you notice that when a transaction fails validation, the service throws an IllegalStateException before closing the database connection, causing a resource leak. You need to ensure that the database connection is always closed properly, even if an exception is thrown during validation. The current code structure is:

try (Connection conn = DriverManager.getConnection(url, user, pass)) { // read from queue // validate transaction // if invalid, throw new IllegalStateException("Invalid transaction"); // write to database

Which course of action would you recommend?

Trap 1: Move the connection creation outside the try-with-resources to…

Manual management is error-prone and defeats the purpose of try-with-resources.

Trap 2: Replace the try-with-resources with a try-catch-finally block and…

This would work but is more verbose and unnecessary. The try-with-resources is preferred and already handles it.

Trap 3: Add a catch block to catch the IllegalStateException and close the…

The try-with-resources already closes the connection automatically; additional catch is not needed for cleanup.

A
Move the connection creation outside the try-with-resources to manually manage it.
Why wrong: Manual management is error-prone and defeats the purpose of try-with-resources.
B
No change is needed; the try-with-resources ensures the connection is closed.
try-with-resources automatically closes the resource, even if an exception is thrown.
C
Replace the try-with-resources with a try-catch-finally block and close the connection in the finally block.
Why wrong: This would work but is more verbose and unnecessary. The try-with-resources is preferred and already handles it.
D
Add a catch block to catch the IllegalStateException and close the connection.
Why wrong: The try-with-resources already closes the connection automatically; additional catch is not needed for cleanup.

Question 9easymulti select

Which TWO statements about the try-with-resources statement are true? (Choose two.)

Trap 1: The resources must implement the Closeable interface.

Incorrect: Resources must implement AutoCloseable, which is a superinterface of Closeable.

Trap 2: Resources can be reassigned inside the try block.

Incorrect: Resources declared in try-with-resources are effectively final and cannot be reassigned.

Trap 3: Multiple resources are separated by commas.

Incorrect: Multiple resources are separated by semicolons.

A
The resources must implement the Closeable interface.
Why wrong: Incorrect: Resources must implement AutoCloseable, which is a superinterface of Closeable.
B
Resources can be reassigned inside the try block.
Why wrong: Incorrect: Resources declared in try-with-resources are effectively final and cannot be reassigned.
C
Resources declared in the try-with-resources block are closed automatically.
Correct: The try-with-resources statement ensures each resource is closed at the end of the statement.
D
Resources are closed in the reverse order of their declaration.
Correct: Resources are closed in reverse order to avoid dependency issues.
E
Multiple resources are separated by commas.
Why wrong: Incorrect: Multiple resources are separated by semicolons.

Question 10mediummultiple choice

What is the output when the code is executed?

Exhibit

Refer to the exhibit.

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Arithmetic");
            throw e;
        } catch (Exception e) {
            System.out.println("Exception");
        } finally {
            System.out.println("Finally");
        }
    }
}

Trap 1: Arithmetic Finally

Incorrect: This would be the output if the exception were not rethrown after the catch block.

Trap 2: Arithmetic Exception Finally

Incorrect: The second catch block is not reached because the exception is rethrown from the first catch.

Trap 3: Exception Finally

Incorrect: The ArithmeticException is caught first, so 'Arithmetic' is printed, not 'Exception'.

A
Arithmetic Finally
Why wrong: Incorrect: This would be the output if the exception were not rethrown after the catch block.
B
Arithmetic Exception Finally
Why wrong: Incorrect: The second catch block is not reached because the exception is rethrown from the first catch.
C
Exception Finally
Why wrong: Incorrect: The ArithmeticException is caught first, so 'Arithmetic' is printed, not 'Exception'.
D
Arithmetic Finally [stack trace]
Correct: 'Arithmetic' is printed, then finally prints 'Finally', then the rethrown exception causes a stack trace.

Question 11hardmultiple choice

You are developing a microservice that processes order payments. The service uses a custom exception hierarchy: PaymentException (checked), InsufficientFundsException (unchecked, extends RuntimeException), and NetworkException (checked, extends PaymentException). The processPayment method is declared as: public void processPayment(Order order) throws PaymentException. Inside, a call to an external payment gateway may throw InsufficientFundsException or NetworkException. The requirement is to log all payment failures to an audit system, but the service must continue processing other orders. The audit logging method is: public void logFailure(String message) throws Exception. Which approach best handles exceptions while meeting the requirements?

Trap 1: Wrap the call to the payment gateway in a try-catch-finally block

Incorrect: Even if the method returns, the catch block must handle the exception properly; logFailure is declared to throw Exception, so it must be caught or declared.

Trap 2: Add a throws clause to processPayment for…

Incorrect: The caller would need to handle these exceptions, and the requirement is to continue processing, not propagate.

Trap 3: Catch InsufficientFundsException and NetworkException separately,…

Incorrect: Throwing a RuntimeException propagates the error, stopping processing of other orders.

A
Wrap the call to the payment gateway in a try-catch-finally block. In the catch block, log the error using logFailure. In the finally block, return from the method.
Why wrong: Incorrect: Even if the method returns, the catch block must handle the exception properly; logFailure is declared to throw Exception, so it must be caught or declared.
B
Add a throws clause to processPayment for InsufficientFundsException and NetworkException, and let the caller handle them.
Why wrong: Incorrect: The caller would need to handle these exceptions, and the requirement is to continue processing, not propagate.
C
Catch InsufficientFundsException and NetworkException in separate catch blocks. Inside each, try to call logFailure; if logFailure throws an exception, catch it and log a generic message to a fallback logger. Then return normally from processPayment without throwing.
Correct: This handles all exceptions, logs the failure, and allows the method to return normally so the service continues.
D
Catch InsufficientFundsException and NetworkException separately, log the error using logFailure, and then throw a new RuntimeException to indicate failure.
Why wrong: Incorrect: Throwing a RuntimeException propagates the error, stopping processing of other orders.

Question 12mediumdrag order

Order the steps to compile and run a simple Java program from the command line.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps

Order

1Step 1

2Step 2

3Step 3

4Step 4

5Step 5

Question 13mediummatching

Match each JDBC type to its corresponding Java type.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts

Matches

String

int

long

boolean

java.sql.Timestamp

Question 14easymultiple choice

A method reads a file and throws IOException. Which of the following is the correct way to declare the method?

Trap 1: public void readFile() throws RuntimeException { ..

Wrong exception type; IOException is checked.

Trap 2: public void readFile() throws Exception { ..

Too generic; should be specific IOException.

Trap 3: public void readFile() { ..

Must handle or declare the checked exception.

A
public void readFile() throws RuntimeException { ... }
Why wrong: Wrong exception type; IOException is checked.
B
public void readFile() throws Exception { ... }
Why wrong: Too generic; should be specific IOException.
C
public void readFile() { ... } // assumes try-catch inside
Why wrong: Must handle or declare the checked exception.
D
public void readFile() throws IOException { ... }
Correctly declares IOException.

Question 15mediummultiple choice

Consider the following code snippet:

try { // some code

} catch (IOException e) {

// handle

} catch (FileNotFoundException e) { // Line X

// handle

What will be the result?

Trap 1: The code compiles and runs without issues.

FileNotFoundException is a subclass of IOException, so the order causes unreachable code.

Trap 2: The code compiles but throws a ClassCastException at runtime.

No runtime exception related to catch ordering.

Trap 3: The code compiles but the second catch never executes.

Compilation fails, so it never runs.

A
The code compiles and runs without issues.
Why wrong: FileNotFoundException is a subclass of IOException, so the order causes unreachable code.
B
The code compiles but throws a ClassCastException at runtime.
Why wrong: No runtime exception related to catch ordering.
C
The code compiles but the second catch never executes.
Why wrong: Compilation fails, so it never runs.
D
Compilation fails at Line X with an error about an exception already caught.
Correct: FileNotFoundException is already caught by IOException.

Question 16hardmultiple choice

Given a try-with-resources statement where both the try block and the close method of the resource throw exceptions, which of the following is true about exception handling?

Trap 1: The exception from the close method is the primary exception.

The try block exception is primary.

Trap 2: Both exceptions are thrown simultaneously, causing a multi-catch.

Only one exception is propagated; the other is suppressed.

Trap 3: The close method exception is ignored if the try block succeeds.

If try succeeds, close exception is thrown normally.

A
The exception from the close method is the primary exception.
Why wrong: The try block exception is primary.
B
Both exceptions are thrown simultaneously, causing a multi-catch.
Why wrong: Only one exception is propagated; the other is suppressed.
C
The try block exception is the primary exception; the close exception is suppressed.
Correct behavior of try-with-resources.
D
The close method exception is ignored if the try block succeeds.
Why wrong: If try succeeds, close exception is thrown normally.

Question 17easymultiple choice

In a try-finally block, what happens to a return statement inside the finally block?

Trap 1: The finally block is skipped if there is a return in try.

Finally always executes.

Trap 2: The return in the try block takes precedence.

Finally return overrides.

A
The return in the finally block is executed, and the try block return is ignored.
Finally return overrides try return.
B
The finally block is skipped if there is a return in try.
Why wrong: Finally always executes.
C
The return in the try block takes precedence.
Why wrong: Finally return overrides.
D
If the try block throws an exception, the finally return overrides the exception.
Yes, that's also true; but the question asks about return statement. The correct answer is B.

Question 18mediummultiple choice

Which of the following is a best practice when creating a custom exception class?

Trap 1: Implement the Exception interface.

Exception is a class, not an interface.

Trap 2: Extend Error to indicate a serious system error.

Error is for JVM errors, not application exceptions.

Trap 3: Extend Throwable directly to create a new exception type.

Should extend Exception or RuntimeException.

A
Implement the Exception interface.
Why wrong: Exception is a class, not an interface.
B
Extend Error to indicate a serious system error.
Why wrong: Error is for JVM errors, not application exceptions.
C
Extend RuntimeException for an unchecked exception.
Standard practice for custom exceptions that represent programming errors.
D
Extend Throwable directly to create a new exception type.
Why wrong: Should extend Exception or RuntimeException.

Question 19hardmultiple choice

Given the following assertion: assert age >= 0 : "Age must be non-negative"; When is it appropriate to use assertions?

Trap 1: To handle recoverable conditions like file not found.

Use try-catch for recoverable conditions.

Trap 2: To check parameters of a public API method.

Parameters should be validated with IllegalArgumentException.

Trap 3: To validate user input from an external system.

Assertions can be disabled, so input should be validated with exceptions.

A
To verify internal invariants of a private method.
Assertions are perfect for internal consistency checks.
B
To handle recoverable conditions like file not found.
Why wrong: Use try-catch for recoverable conditions.
C
To check parameters of a public API method.
Why wrong: Parameters should be validated with IllegalArgumentException.
D
To validate user input from an external system.
Why wrong: Assertions can be disabled, so input should be validated with exceptions.

Question 20easymultiple choice

Which of the following is a checked exception in Java?

Trap 1: NullPointerException

Unchecked.

Trap 2: ArrayIndexOutOfBoundsException

Unchecked.

Trap 3: IllegalArgumentException

Unchecked.

A
NullPointerException
Why wrong: Unchecked.
B
ArrayIndexOutOfBoundsException
Why wrong: Unchecked.
C
SQLException
Checked exception.
D
IllegalArgumentException
Why wrong: Unchecked.