1Z0-829 Handling Exceptions Practice Test 4 — 15 Questions

Question 1

A developer wants to ensure that a block of code always executes regardless of whether an exception occurs or not, and that any exception thrown in the block is not swallowed. Which construct should be used?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

try-finally. The try-finally construct ensures that the finally block always executes after the try block, regardless of whether an exception occurs, and it does not catch or swallow any exception. This meets the requirement of guaranteed execution without suppressing the exception, as the exception propagates up the call stack.

Answer

try-catch with empty catch block

Answer

try-catch-finally with catch that rethrows the exception

Answer

try-with-resources without catch

Question 2

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

Accepted Answer

Resources are closed in the reverse order of their declaration.. Option A is correct because try-with-resources closes resources in the reverse order of their declaration, i.e., the last resource declared is closed first, mirroring a stack-like LIFO teardown. Option E is correct because if the try block throws an exception and a resource's close() method also throws, the try block's exception is the one that propagates while the close() exception is attached to it via addSuppressed(), retrievable with getSuppressed(). Option B is wrong because it states the opposite ordering (same order as declaration) rather than the required reverse order. Option C is wrong because resources need not implement java.io.Closeable specifically; they may implement java.lang.AutoCloseable, which is broader and includes Closeable as a subinterface. Option D is wrong because it claims earlier-declared resources close first, which contradicts the reverse-order rule.

Answer

Resources are closed in the same order as their declaration.

Answer

Resources declared in try-with-resources must implement the Closeable interface.

Answer

Resources declared earlier in the try clause are closed first.

Question 3

Which THREE practices are recommended for effective exception handling? (Choose three.)

Accepted Answer

Throw exceptions early, catch them late, but handle them at the appropriate level.. Option A is correct because the recommended pattern is to detect and throw an exception as soon as the error condition is detected (throw early), let it propagate up the call stack (catch late), and only handle it at the layer that has enough context to recover or translate it meaningfully. Option C is correct because try-with-resources automatically invokes close() on any AutoCloseable resource at the end of the block, eliminating the boilerplate and error-prone manual close() in a finally block and correctly handling suppressed exceptions. Option E is correct because catching specific exception types (e.g., IOException, SQLException) allows precise, targeted handling and avoids accidentally swallowing unrelated runtime errors that a broad catch (Exception) would mask. Option B is not recommended because custom exceptions should carry meaningful context (messages, cause, relevant fields) to aid diagnosis, not be defined without additional context. Option D is not recommended because catching everything at the highest level and logging generically loses the specific handling each layer should perform and produces vague, hard-to-diagnose logs.

Answer

Define custom exceptions without providing any additional context.

Answer

Catch exceptions at the highest level of the application and log them generically.

Question 4

Which TWO of the following are unchecked exceptions? (Choose two.)

Accepted Answer

NullPointerException. NullPointerException (C) is correct because it extends RuntimeException, which is the root of all unchecked exceptions, and it is thrown by the JVM at runtime when an application attempts to use a null reference. ArrayIndexOutOfBoundsException (D) is also correct because it extends IndexOutOfBoundsException, itself a subclass of RuntimeException, so it is unchecked and need not be declared or caught. By contrast, SQLException (A) and IOException (E) are checked exceptions that extend Exception directly and must be handled or declared, while Exception (B) is the general checked superclass (excluding RuntimeException and its subclasses), so it is not itself an unchecked exception.

Answer

SQLException

Answer

Exception

Answer

IOException

Question 5

A Java application uses a custom resource class implementing AutoCloseable. The close() method throws a checked exception. In a try-with-resources block, if both the try block and the close() method throw exceptions, which exception is propagated to the caller? Assume the resource is declared in try-with-resources.

Accepted Answer

The exception from the try block is the primary exception, and the close() exception is added as a suppressed exception.. In a try-with-resources block, when both the try block and the close() method throw exceptions, the exception from the try block is the primary exception propagated to the caller. The exception thrown by close() is added to the primary exception's suppressed exception list, as defined by the Java Language Specification (JLS §14.20.3.2). This ensures that the most relevant exception (the one from the application logic) is not masked by a resource-closing failure.

Answer

The exception from close() is always the primary exception.

Answer

Both exceptions are thrown simultaneously as a multi-catch exception.

Answer

The exception from the try block is always suppressed.

Question 6

Which TWO are valid multi-catch statements in Java 17? (Choose two.)

Accepted Answer

catch (SQLException | IOException e). Option A is correct because catch (SQLException | IOException e) is a valid multi-catch: SQLException and IOException are unrelated checked exception types (neither is a subclass of the other), so the alternatives are disjoint and the compiler accepts them. Option E is correct because catch (IOException | RuntimeException e) combines a checked exception with an unchecked exception that are unrelated in the class hierarchy, which is also legal in Java 7+ multi-catch syntax. Option B is invalid because Exception is a supertype of RuntimeException, so the alternatives are not disjoint and the compiler rejects the redundancy. Option C is invalid for the same reason: SQLException is a subclass of Exception, making the multi-catch alternatives related by inheritance. Option D is invalid because FileNotFoundException is a subclass of IOException, so listing both in one multi-catch is a compile-time error.

Answer

catch (Exception | RuntimeException e)

Answer

catch (SQLException | Exception e)

Answer

catch (IOException | FileNotFoundException e)

Question 7

You are developing a batch processing application that reads records from a CSV file and parses each row into an integer ID. The reading method readNextRecord() returns a String and can throw IOException and NumberFormatException. The method processID(int id) processes the ID. The entire process runs in a for loop over 10,000 records. The requirement is that if any record fails (either due to file read error or parsing), the loop must continue to the next record, but the exception must be logged for later review. Which approach best achieves this requirement?

Accepted Answer

Inside the loop, wrap the readNextRecord() and processID() calls in a try-catch block that catches IOException and NumberFormatException separately, logs the exception, and continues.. It places a try-catch block inside the loop that catches IOException and NumberFormatException separately, logs each exception, and then continues to the next iteration. This ensures that a failure in reading or parsing any single record does not terminate the loop, and each exception is logged individually for later review, meeting the requirement precisely.

Answer

Surround the entire loop with a try-catch block that catches IOException and NumberFormatException using multi-catch, logs once, and allows the loop to continue.

Answer

Inside the loop, wrap the calls in a try-catch that catches Exception, logs, and continues.

Answer

Declare the method to throw IOException and NumberFormatException and let the caller handle them.

Question 8

Which two statements about multi-catch blocks are correct?

Accepted Answer

A multi-catch block can be used with a finally block.. Option B is correct because a multi-catch block is simply an alternative form of a catch clause, so it can be freely combined with a finally block (and with other catch clauses) in the same try statement, e.g. try { ... } catch (IOException | SQLException e) { ... } finally { ... }. Option E is correct because the exception parameter types listed in a multi-catch must be disjoint — the compiler rejects alternatives where one type is a subclass of another (e.g. catch (IOException | FileNotFoundException e) fails), since the parameter is implicitly final and typed as the least upper bound of the alternatives. Option A is wrong because a multi-catch may combine checked and unchecked exception types, such as catch (IOException | IllegalArgumentException e), as long as the alternatives are disjoint. Option C is wrong because the multi-catch parameter is implicitly final, which is exactly why it cannot be reassigned inside the handler. Option D is wrong because multi-catch is independent of try-with-resources; it works with any try statement, with or without resources.

Answer

A multi-catch block cannot catch both checked and unchecked exceptions.

Answer

The variable in a multi-catch block is not implicitly final.

Answer

A multi-catch block can only be used with try-with-resources.

Question 9

A financial trading application uses Java 17 and processes millions of transactions per second. It uses a custom checked exception `TradeException extends Exception` for business rule violations. Recently, the transaction processing service began throwing a `RuntimeException` that wraps a `TradeException`, but the error logs only show the wrapper's message and stack trace, missing the original `TradeException` details. The logging framework prints the exception and its cause chain. The development team needs to ensure that the original `TradeException` message and stack trace are always logged. What is the most appropriate course of action?

Accepted Answer

Modify the exception wrapping code to pass the original TradeException as a cause to the RuntimeException constructor.. Passing the original `TradeException` as the cause argument to the `RuntimeException` constructor (e.g., `new RuntimeException(message, cause)`) preserves the full cause chain. The logging framework, which prints the exception and its cause chain, will then output both the wrapper's stack trace and the original `TradeException`'s message and stack trace, ensuring complete visibility.

Answer

Catch the RuntimeException in the main processing loop and print the cause's message using getCause().getMessage().

Answer

Modify the TradeException class to extend RuntimeException.

Answer

Override the getMessage() method in TradeException to return the original message.

Question 10

A developer writes a try-with-resources statement that opens two `AutoCloseable` resources: `r1` then `r2`. The try block throws an exception, and then `r2.close()` throws an exception, followed by `r1.close()` throwing an exception. Which exception is propagated to the caller?

Accepted Answer

The exception from the try block, with the close exceptions added as suppressed exceptions.. In try-with-resources, the exception thrown in the try block is the primary exception. If closing resources also throws exceptions, those are added as suppressed exceptions to the primary one. The resources are closed in reverse order of their declaration, so r2 closes before r1, but both close exceptions are suppressed on the try block's exception.

Answer

A new exception is thrown that combines all three exceptions.

Answer

The exception from r1.close(), with the others as suppressed.

Answer

The exception from r2.close(), with the others as suppressed.

Question 11

A Java 17 service defines a custom checked exception named InventoryException that extends Exception. A developer writes the following method:

public void reserve() {
    throw new InventoryException("out of stock");
}

What is the result when compiling this class?

Accepted Answer

Compilation fails because InventoryException must be declared in the throws clause of reserve().. InventoryException extends Exception, making it a checked exception. Java's compiler requires every checked exception thrown by a method body to be either caught inside that method or listed in its throws clause. Because reserve() does neither, the class fails to compile, regardless of whether the exception would ever be thrown at runtime.

Answer

Compilation succeeds, but the exception is silently ignored at runtime.

Answer

Compilation succeeds because a method may throw any exception type without declaring it.

Answer

Compilation succeeds, and the exception is automatically wrapped in a RuntimeException at runtime.

Question 12

A developer writes a method that declares `throws SQLException`. Inside a `try` block, it calls `connection.prepareStatement(sql)`. The developer adds a `catch (IOException e)` block after the `try` to handle potential errors. What is the result when compiling this code with Java 17?

Accepted Answer

Compilation fails because IOException is not thrown in the try block and is not a supertype of SQLException.. A catch clause for a checked exception is only allowed if that exception (or a subtype) can be thrown in the corresponding try block. Since the try block only declares SQLException, catching IOException is invalid and causes a compilation error. The compiler verifies exception reachability at compile time.

Answer

Compilation fails because SQLException must be caught before IOException.

Answer

Compilation succeeds because catch blocks can handle any exception type regardless of what is thrown.

Answer

Compilation succeeds but a warning is issued about the unused catch block.

Question 13

A developer writes a method that must clean up a temporary file whether or not the processing code inside the try block succeeds. The cleanup code does not depend on any variables declared inside the try block. Which construct should the developer use to guarantee the cleanup runs in all normal exit paths?

Accepted Answer

A finally block attached to the try statement.. The finally block is designed to execute on every normal exit path from a try statement, including normal completion, return, and exception propagation. Because the cleanup does not rely on try-local variables, finally is the appropriate and idiomatic choice. Catch blocks only run on exceptions, and synchronization addresses concurrency rather than cleanup.

Answer

A synchronized block surrounding the processing code.

Answer

A catch block that catches Exception and performs the cleanup.

Answer

A catch block that catches Throwable and performs the cleanup.

Question 14

A Java 17 batch application defines a custom exception class `ParseException` that extends `Exception`. The method `parseConfig()` declares `throws ParseException` and reads a configuration file using `Files.newBufferedReader`. The method `load()` calls `parseConfig()` but contains no `try` block. Which statement describes the compilation result?

Accepted Answer

Compilation succeeds only if `load()` also declares `throws ParseException` or catches it.. A checked exception must be either caught or declared by any method that invokes a method declaring it. Since `ParseException` extends `Exception`, it is checked, and `load()` does neither. The compiler therefore rejects the code until `load()` declares `throws ParseException` or wraps the call in a `try`/`catch`. This is the standard catch-or-specify contract.

Answer

Compilation fails because `parseConfig()` must declare `throws IOException` instead of `ParseException`.

Answer

Compilation succeeds because `ParseException` is a custom class and the compiler cannot verify it.

Answer

Compilation succeeds because `parseConfig()` reads a file, and file operations are unchecked.

Question 15

A developer writes a method that declares `throws SQLException` and contains a try-with-resources block. Inside the try, a `Connection` is opened and a query is executed. The method must guarantee that the `Connection` is closed even if the query throws an exception. Which statement best describes the behavior of the following code?

```java
public void query() throws SQLException {
    try (Connection conn = DriverManager.getConnection(url)) {
        executeQuery(conn);
    }
}
```

Accepted Answer

The connection is closed automatically when the try block exits, whether normally or due to an exception, and any exception from `close()` is suppressed if the try block throws.. Try-with-resources ensures deterministic cleanup by invoking `close()` on any resource declared in the resource specification, regardless of whether the try block completes normally or throws. If the try block throws and `close()` also throws, the close exception is suppressed and attached to the primary exception, which can be retrieved via `getSuppressed()`. This makes resource management robust and concise.

Answer

The connection is not closed because `Connection` does not implement `AutoCloseable`; the developer must manually close it in a finally block.

Answer

The connection is closed only if `executeQuery` throws an exception; if it completes normally, the connection stays open until garbage collection.

Answer

The connection is closed only if `executeQuery` completes normally; if it throws, the connection remains open.