1Z0-829 Handling Exceptions — Timed 10 Questions

Question 1

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?

Accepted Answer

try (BufferedReader reader = Files.newBufferedReader(path)) { ... } catch (IOException e) { throw new ApplicationException(e); }. Option C is correct because it uses a try-with-resources statement, which automatically closes the BufferedReader (which implements AutoCloseable) when the block exits, whether normally or exceptionally. The catch clause then catches any IOException and wraps it in a custom ApplicationException, satisfying both the resource-closing and exception-wrapping requirements without manual cleanup.

Answer

try { ... } catch (IOException e) { System.err.println(e); } finally { reader.close(); }

Answer

catch (Exception e) { throw new ApplicationException(e); } finally { reader.close(); }

Answer

try { ... reader.close(); } catch (IOException e) { throw new ApplicationException(e); }

Question 2

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?

Accepted Answer

public void log(String message) throws LogException { ... }. Option A is correct because it declares the checked exception LogException in the throws clause, which forces callers to either handle it with a try-catch or propagate it by declaring throws in their own method. This satisfies the requirement that callers can choose how to deal with the exception, as checked exceptions must be acknowledged at compile time.

Answer

public void log(String message) { ... }

Answer

public void log(String message) throws Error { ... }

Answer

public void log(String message) throws RuntimeException { ... }

Question 3

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

Accepted Answer

The resource class must implement AutoCloseable.. Option A is correct because the try-with-resources statement requires that each resource implements the AutoCloseable interface (or its subinterface Closeable). This interface defines the close() method, which is automatically invoked by the JVM when the try block completes, ensuring proper resource management without explicit finally blocks.

Answer

The resource variable must be declared as final.

Answer

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

Answer

Resources are closed before the try block executes.

Question 4

What is the result when the main method is executed?

Accepted Answer

C is printed and the program terminates.. The correct answer is C because the code demonstrates that when an exception is thrown in a try block, the corresponding catch block for that exception type is executed, and then the finally block runs. After the finally block completes, the program terminates normally. In this case, the try block throws an ArithmeticException, which is caught by the catch block that prints 'C', and then the finally block executes but does not change the output.

Answer

Both B and C are printed and the program terminates.

Answer

B is printed and the program terminates.

Answer

A is printed and the program terminates.

Question 5

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?

Accepted Answer

Rewrite the code to use try-with-resources: try (UploadSession session = new UploadSession()) { ... } catch (UploadException e) { ... }. Option D is correct because try-with-resources automatically calls the close() method on the UploadSession resource when the try block exits, whether normally or abruptly. This eliminates the need for an explicit finally block and ensures that any checked exception thrown by close() is either caught or propagated according to the developer's declared exception handling, making the code both robust and concise.

Answer

Add a try-catch block inside the finally block to handle CloseException from session.close().

Answer

Declare the method with throws CloseException, and remove the finally block.

Answer

Keep the code as-is. The CloseException is not critical; it can be ignored.

Question 6

Which TWO of the following are checked exceptions in Java?

Accepted Answer

SQLException. A is correct because `SQLException` is a subclass of `java.lang.Exception` (which is a checked exception class) and does not extend `RuntimeException`. Checked exceptions must be either caught or declared in the method signature; `SQLException` is commonly thrown when database access errors occur, such as connection failures or SQL syntax errors.

Answer

ArithmeticException

Answer

ArrayIndexOutOfBoundsException

Answer

NullPointerException

Question 7

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

Accepted Answer

The SQLException is a checked exception, and the code must handle it or declare it.. Option C is correct because SQLException is a checked exception (a subclass of Exception but not RuntimeException), so the Java compiler enforces that it must be either caught in a try-catch block or declared in the throws clause of the enclosing method. The stack trace indicates that an SQLException occurred, and the code must handle this checked exception to compile successfully.

Answer

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

Answer

The RuntimeException is caused by a checked exception, so it must be declared in the throws clause.

Answer

The RuntimeException is an unchecked exception, so it cannot be caught.

Question 8

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?

Accepted Answer

No change is needed; the try-with-resources ensures the connection is closed.. Option B is correct because try-with-resources automatically closes any resource that implements AutoCloseable (including Connection) when the try block exits, whether normally or via an exception. The IllegalStateException thrown during validation does not prevent the connection from being closed; the close() method is called as part of the implicit finally block generated by the compiler.

Answer

Move the connection creation outside the try-with-resources to manually manage it.

Answer

Replace the try-with-resources with a try-catch-finally block and close the connection in the finally block.

Answer

Add a catch block to catch the IllegalStateException and close the connection.

Question 9

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

Accepted Answer

Resources declared in the try-with-resources block are closed automatically.. Option C is correct because the try-with-resources statement automatically closes each resource declared in the resource specification after the try block completes, whether normally or abruptly. This is the primary purpose of the construct: to ensure reliable resource cleanup without requiring an explicit finally block.

Answer

The resources must implement the Closeable interface.

Answer

Resources can be reassigned inside the try block.

Answer

Multiple resources are separated by commas.

Question 10

What is the output when the code is executed?

Accepted Answer

Arithmetic
Finally
[stack trace]. Option D is correct because the code throws an ArithmeticException (division by zero) inside the try block, which is caught by the first catch block (ArithmeticException). The finally block always executes after the catch block, printing 'Finally'. The stack trace is printed because the exception is re-thrown in the catch block (implicitly or explicitly) and not handled, causing the program to terminate with an uncaught exception. The output shows 'Arithmetic', then 'Finally', followed by the stack trace.

Answer

Arithmetic
Finally

Answer

Arithmetic
Exception
Finally

Answer

Exception
Finally