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

Question 1

A Java 17 service uses a `try` block with a `finally` clause that calls `connection.close()`. The `close()` method can throw a `SQLException`. Inside the `try` block, a `RuntimeException` is thrown. What is the outcome when both the `try` block throws and `close()` also throws during `finally`?

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

Accepted Answer

The `SQLException` from `finally` propagates, and the original `RuntimeException` is lost.. A `finally` block that throws an exception replaces the exception from the `try` block. The original `RuntimeException` is lost, and only the `SQLException` from `close()` reaches the caller. This is why try-with-resources is preferred: it automatically suppresses secondary exceptions from `close()` while preserving the primary one.

Answer

Both exceptions propagate as a single combined exception with the `RuntimeException` as the cause.

Answer

The `RuntimeException` from the `try` block propagates, and the `SQLException` is suppressed.

Answer

The `RuntimeException` propagates, and the `SQLException` is added to its suppressed exceptions list.

Question 2

A Java 17 service defines a custom checked exception `PaymentException` and a subclass `RetryablePaymentException`. A method declares `throws RetryablePaymentException`. A caller wraps the invocation in a `try` block with a single `catch (PaymentException e)` clause. What is the result?

Accepted Answer

It compiles, and the catch block handles both `PaymentException` and `RetryablePaymentException`.. A catch clause is allowed to catch a supertype of the thrown checked exception. Since `RetryablePaymentException` is a subclass of `PaymentException`, the single handler receives both the declared subtype and any sibling that is also a `PaymentException`. Exact type matching is not a Java requirement, and no extra throws declaration is needed when the exception is handled.

Answer

It fails to compile because checked exceptions cannot be caught when a subclass is involved.

Answer

It fails to compile because the catch parameter must exactly match the declared exception type.

Answer

It compiles only if the catch clause also declares `throws PaymentException` in its own signature.

Question 3

A developer writes a method that catches an exception and rethrows it after logging. The code is:

```java
try {
    process();
} catch (IOException e) {
    log(e);
    throw e;
}
```

The method signature is `public void run() throws IOException`. However, the developer wants to also catch `SQLException` and rethrow it without changing the method signature. Which modification is valid?

Accepted Answer

Wrap the `SQLException` in a new `IOException` and throw that, allowing the method signature to remain `throws IOException`.. To catch `SQLException` and rethrow it without changing the method signature that declares `throws IOException`, the developer can wrap the `SQLException` in an `IOException` (or a subclass) and throw that. This preserves the method's contract while still propagating the original cause via the exception's cause chain. Alternatively, precise rethrow analysis could allow rethrowing if the try block only throws exceptions that are already declared, but here `SQLException` is not declared.

Answer

Change the catch to `catch (IOException | SQLException e)` and rethrow `e`; the method signature must be updated to `throws IOException, SQLException`.

Answer

Change the catch to `catch (IOException | SQLException e)` and rethrow `e`; the method signature can remain `throws IOException` because the compiler uses precise rethrow analysis.

Answer

Catch `SQLException` and throw a new `RuntimeException` without declaring it, because `RuntimeException` is unchecked.

Question 4

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); }. 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 5

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 { ... }. 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 6

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

Accepted Answer

The resource class must implement AutoCloseable.. 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 7

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) { ... }. 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 8

Which TWO of the following are checked exceptions in Java?

Accepted Answer

SQLException. SQLException (A) is a checked exception because it directly extends java.lang.Exception (via java.sql.SQLException) and is not a subclass of RuntimeException, so the compiler requires it to be declared in a throws clause or caught. IOException (E) is likewise a checked exception, extending java.lang.Exception through java.io.IOException, and must be handled or declared for file, stream, and network I/O operations. The unmarked options do not belong because ArithmeticException (B), ArrayIndexOutOfBoundsException (C), and NullPointerException (D) all extend RuntimeException, making them unchecked exceptions that the compiler does not force callers to catch or declare.

Answer

ArithmeticException

Answer

ArrayIndexOutOfBoundsException

Answer

NullPointerException

Question 9

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.. 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 10

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 defining purpose of try-with-resources is that any resource declared in the try header is automatically closed when the try block exits, whether normally or via an exception, without requiring an explicit finally block. Option D is correct because when multiple resources are declared, the compiler generates closing logic that closes them in the reverse order of declaration (last declared, first closed), which matters when resources depend on one another. Option A is not strictly true because resources need only implement AutoCloseable (Closeable is a narrower subinterface), so the statement is too restrictive. Option B is false because resource variables declared in the try header are implicitly final and cannot be reassigned inside the try block. Option E is false because multiple resources are separated by semicolons, not commas.

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 11

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?

Accepted Answer

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.. It ensures that both checked (NetworkException) and unchecked (InsufficientFundsException) exceptions are caught locally, allowing the service to log the failure via logFailure (which itself throws Exception) without propagating the exception up the call stack. By catching any exception from logFailure and falling back to a generic logger, the method guarantees that processPayment returns normally, meeting the requirement to continue processing other orders. This approach respects the checked exception contract of processPayment (throws PaymentException) while handling all failure scenarios internally.

Answer

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.

Answer

Add a throws clause to processPayment for InsufficientFundsException and NetworkException, and let the caller handle them.

Answer

Catch InsufficientFundsException and NetworkException separately, log the error using logFailure, and then throw a new RuntimeException to indicate failure.

Question 12

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

Accepted Answer

Write the Java source code in a .java file, then compile with javac to produce a .class file, then run the class using java.. javac produces .class files; java runs the main method of the specified class. The classpath may need to be set if dependencies exist.

Answer

Write the Java source code in a .java file, then run with java, then compile with javac.

Answer

Compile with javac, then write the Java source code in a .java file, then run with java.

Answer

Run with java, then compile with javac, then write the Java source code in a .java file.

Question 13

Match each JDBC type to its corresponding Java type.

Accepted Answer

VARCHAR: String. JDBC provides standard mappings from SQL types to Java types: VARCHAR to String, INTEGER to int, DATE to java.sql.Date, BLOB to java.sql.Blob, and CLOB to java.sql.Clob. Common confusions arise from mixing these mappings.

Answer

VARCHAR: java.sql.Date

Answer

INTEGER: String

Question 14

Consider the following code snippet:

try {
    // some code
} catch (IOException e) {
    // handle
} catch (FileNotFoundException e) { // Line X
    // handle
}

What will be the result?

Accepted Answer

Compilation fails at Line X with an error about an exception already caught.. In Java, when catching exceptions, the more specific exception subclass must be caught before the more general superclass. FileNotFoundException is a subclass of IOException, so catching IOException first makes the catch for FileNotFoundException unreachable, causing a compilation error at Line X.

Answer

The code compiles and runs without issues.

Answer

The code compiles but throws a ClassCastException at runtime.

Answer

The code compiles but the second catch never executes.

Question 15

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?

Accepted Answer

The try block exception is the primary exception; the close exception is suppressed.. In a try-with-resources statement, if both the try block and the resource's close() method throw exceptions, the exception from the try block is the primary exception, and any exception thrown by close() is added as a suppressed exception. This is defined by Java's try-with-resources semantics (JLS §14.20.3.2), ensuring the primary exception is not masked by resource cleanup failures.

Answer

The exception from the close method is the primary exception.

Answer

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

Answer

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