1Z0-829 Handling Exceptions — 40 Questions

Question 1

What is the result when the main method is executed?

Accepted Answer

C is printed and the program terminates.. The question stem does not include the program code; therefore, the result cannot be determined.

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 2

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

What is the output when the code is executed?

Accepted Answer

Arithmetic
Finally
[stack trace]. 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

Question 4

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

Accepted Answer

public void readFile() throws IOException { ... }. The method explicitly declares that it throws IOException, which is a checked exception. In Java, if a method can throw a checked exception like IOException, it must either handle it with a try-catch block or declare it in the throws clause. This allows the caller to handle the exception appropriately.

Answer

public void readFile() throws RuntimeException { ... }

Answer

public void readFile() throws Exception { ... }

Answer

public void readFile() { ... } // assumes try-catch inside

Question 5

Given the exhibit showing a compilation error at line 5 of Test.java, which of the following code fragments could be at that line?

Accepted Answer

FileInputStream fis = new FileInputStream("test.txt");. The code at line 5 is a checked exception (FileNotFoundException) that must be handled or declared. The compilation error indicates that the method containing line 5 does not handle or declare this checked exception, which is required by the Java compiler.

Answer

int x = 5;

Answer

try { ... } catch (Exception e) { }

Answer

System.out.println("Hello");

Question 6

Given the following code snippet inside a method:

try {
    // risky code
} catch (IOException | SQLException e) {
    // handle
}

What is the implicit type of the exception variable 'e' in the catch block?

Accepted Answer

It is of type Exception.. In Java, when a multi-catch clause catches multiple exception types (e.g., IOException | SQLException), the compiler infers the catch parameter's type as the closest common superclass that is not Object or Throwable. Since IOException and SQLException both extend Exception directly, the implicit type of 'e' is Exception. This allows the catch block to handle both exception types polymorphically.

Answer

It is of type Object.

Answer

It is of type Throwable.

Answer

It is either IOException or SQLException.

Question 7

What happens when a finally block throws an exception?

Accepted Answer

The exception from the try block is suppressed and the finally exception is reported.. When a finally block throws an exception, the JVM suppresses the exception that was thrown from the try block (if any) and propagates the exception thrown from the finally block. This behavior is defined in the Java Language Specification (JLS §14.20.2) and ensures that the finally block's exception takes precedence, as the finally block is executed after the try block completes abruptly.

Answer

The JVM logs both exceptions and then terminates the thread.

Answer

The exception from the try block is propagated and the finally exception is ignored.

Answer

Both exceptions are reported as suppressed exceptions of a new exception.

Question 8

Which of the following is a checked exception in Java?

Accepted Answer

IOException. IOException is a checked exception in Java. Checked exceptions are subclasses of Exception (excluding RuntimeException and its subclasses), and the compiler enforces that they are either caught or declared in the method's throws clause. IOException directly extends Exception, making it a checked exception that must be handled at compile time.

Answer

NullPointerException

Answer

ArithmeticException

Answer

IllegalArgumentException

Question 9

Given a method that throws IOException, SQLException, and TimeoutException, a developer writes a catch block that rethrows the exception. Using Java 17, which exception types can the catch block declare in its throws clause if the rethrown exception is not modified?

Accepted Answer

Any single exception type that covers all caught exceptions.. In Java, when a catch block catches multiple exception types and rethrows the exception without modification, the compiler uses precise rethrow. This allows the throws clause to declare any exception type that is a supertype of all the caught exceptions, such as Exception (which is a common supertype of IOException, SQLException, and TimeoutException). Therefore, the developer does not need to list each checked exception individually; a single covering type is sufficient. Option D correctly states that any single exception type covering all caught exceptions can be declared.

Answer

The method must declare all checked exceptions individually.

Answer

Only the common superclass of the exceptions (Exception).

Answer

No throws clause is needed if the catch block logs and returns.

Question 10

In the following try-with-resources block, resources are declared as: try (FileInputStream fis = new FileInputStream("data.txt"); BufferedInputStream bis = new BufferedInputStream(fis)) { ... } If an IOException occurs during the closing of both resources, which resource's close exception is returned by e.getSuppressed()?

Accepted Answer

Only the exception from FileInputStream close is in the suppressed array.. In a try-with-resources statement, resources are closed in the reverse order of their declaration. Here, FileInputStream is declared first and BufferedInputStream second, so BufferedInputStream is closed first. If both resources throw an IOException during closing, the exception from BufferedInputStream (the first to close) becomes the primary exception, and the exception from FileInputStream (the second to close) is suppressed. The primary exception is thrown from the try block, while the suppressed exception is accessible via the getSuppressed() method. Therefore, e.getSuppressed() returns an array containing the exception from FileInputStream. Option B is correct because only the FileInputStream's close exception is in the suppressed array.

Answer

The suppressed array contains both exceptions.

Answer

The suppressed array contains the exception from FileInputStream.

Answer

Only the exception from BufferedInputStream close is in the suppressed array.

Question 11

What is the result of executing the code in the exhibit?

Accepted Answer

The code does not compile because methodA does not declare that it throws Exception.. The code does not compile because methodA explicitly throws an IOException, but the catch block in main catches Exception (a broader type). However, the compiler performs improved rethrow analysis only when the exception parameter is effectively final and the catch block is multi-catch or rethrows a checked exception that is declared in the method signature. Here, methodA does not declare that it throws Exception, and the catch block catches Exception, which is not a declared exception in methodA's throws clause, causing a compilation error.

Answer

The code compiles and prints 'Caught in main: IOException' because the compiler uses improved rethrow analysis.

Answer

Prints: Caught in main: Exception

Answer

Prints: Caught in main: IOException

Question 12

Your team manages a high-throughput financial transaction system running on Java 17. Recently, the application experiences intermittent slowdowns and increased CPU usage during peak hours. Monitoring reveals that exception handling code is invoked frequently due to validation errors in incoming data. The system uses a central exception handler that logs every exception and throws a custom ApplicationException. In many places, the code catches generic Exception and rethrows the custom exception after logging. Additionally, method signatures include throws Exception. The team wants to improve performance and maintainability without changing the external behavior significantly. Which course of action best addresses the performance and maintainability issues?

Accepted Answer

Define specific custom checked exception classes for each validation error and catch them precisely, avoiding generic Exception catches.. Catching generic `Exception` forces the JVM to build a full stack trace for every validation error, which is expensive in a high-throughput system. By defining specific custom checked exception classes and catching them precisely, the team reduces unnecessary stack trace generation and makes the code more maintainable by clearly documenting which errors are expected. This approach aligns with Java best practices for exception handling, improving both performance and code clarity without altering external behavior.

Answer

Change all catch blocks to catch Throwable and ignore irrecoverable errors to reduce logging.

Answer

Add a try-catch block around every method call that might throw an exception to handle locally.

Answer

Wrap all exceptions in a single custom unchecked exception to simplify exception handling.

Question 13

A company has a service layer with a method performOperation() that originally declared throws BaseException (a checked exception). Several client methods call performOperation() and catch BaseException, wrapping it in a RuntimeException for propagation. After a system upgrade, the implementation of performOperation() now explicitly throws two new checked exceptions: SubException1 and SubException2, both of which extend BaseException. The client methods must continue to compile without modifying their catch signatures, and they must still handle the new exceptions appropriately. What is the best way to modify the client methods?

Accepted Answer

No change needed because the catch for BaseException catches all subclasses.. In Java, a catch block for a superclass exception type (BaseException) will catch all subclasses (SubException1 and SubException2) due to polymorphism in exception handling. Since the client methods already catch BaseException and wrap it in a RuntimeException, no changes are needed to the catch signatures; the new exceptions are automatically handled. This satisfies the requirement that client methods continue to compile without modifying their catch signatures while still handling the new exceptions appropriately.

Answer

Use a multi-catch block to catch SubException1 and SubException2 and rethrow as RuntimeException.

Answer

Modify the client method signature to declare throws SubException1, SubException2.

Answer

Add separate catch blocks for SubException1 and SubException2 before the existing BaseException catch.

Question 14

A Java 17 application opens a database connection and a file writer inside a single try-with-resources statement. The connection's close() method throws SQLException, and the file writer's close() method throws IOException. The try body itself completes normally. Which two statements correctly describe the resulting behavior? (Choose two.)

Accepted Answer

Resources are closed in the reverse of the order in which they were declared in the resource specification.. Try-with-resources closes resources in reverse declaration order and, when multiple close() calls fail, propagates the first exception while attaching later ones as suppressed exceptions. This behavior mirrors nested try-finally blocks and ensures no cleanup failure is lost. Both statements describe core semantics that developers rely on when debugging resource cleanup problems.

Answer

Because the try body completed normally, no exception can be thrown when the resources are closed.

Answer

Both close() exceptions are merged into a single exception whose message concatenates both messages.

Answer

The exception thrown by the first resource's close() method is always discarded if a later close() also throws.

Question 15

A developer is implementing a method that must throw a custom checked exception `InvalidDataException` when input validation fails. The class `InvalidDataException` extends `Exception`. Which two statements about declaring and throwing this exception are correct? (Choose two.)

Accepted Answer

The method can throw `InvalidDataException` without declaring it if it is caught within the same method.. InvalidDataException is a checked exception, so any method that throws it must either declare it in a throws clause or catch it. If the method catches it internally, no throws clause is required. Declaring throws Exception is broader and not specific, and custom exceptions do not bypass checked exception rules. Declaring an exception that is never thrown is legal but not relevant to the requirement.

Answer

The method can declare `throws InvalidDataException` even if it never throws it.

Answer

The method can throw `InvalidDataException` without declaring it because it is a custom exception.

Answer

The method can declare `throws Exception` instead of `throws InvalidDataException` and still compile.

Question 16

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`?

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 17

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 18

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 19

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 20

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