1Z0-829 Handling Exceptions Practice Test 1 — 15 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.