1Z0-811 Exception Handling and Development Tools Practice Test 4 — 15 Questions

Question 1

A developer writes a method that reads a file and processes its contents. The method uses a BufferedReader wrapped around a FileReader. Which of the following approaches ensures that both resources are properly closed even if an exception occurs?

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

Accepted Answer

Use try-with-resources with both resources declared in the try header.. Try-with-resources ensures that both the BufferedReader and FileReader are automatically closed in reverse order, even if an exception occurs. Option A is wrong because while it attempts to close both resources in separate try-catch blocks within a finally block, this approach is verbose and error-prone; if an exception occurs during the first close, the second close may be skipped unless handled carefully, and it does not guarantee resource closure as reliably as try-with-resources. Option C is wrong because closing only the BufferedReader may close the underlying FileReader due to chaining, but this approach lacks null-safety—if resource creation fails, a NullPointerException occurs when calling close, and it does not demonstrate proper exception handling or best practices. Option D is wrong because throwing a custom exception after closing resources does not ensure both are closed; it adds unnecessary complexity and may leave resources open if close methods throw exceptions.

Answer

Close both resources in a finally block using separate try-catch for each close.

Answer

Close only the BufferedReader in a finally block.

Answer

Throw a custom exception after closing resources in the catch block.

Question 2

A team is designing a library that handles network timeouts. They create a custom exception `NetworkTimeoutException` that extends `Exception`. They want to ensure that callers are forced to handle this exception. Which declaration is appropriate for a method that throws this exception?

Accepted Answer

public void connect() throws NetworkTimeoutException. The method must declare the custom checked exception `NetworkTimeoutException` in its throws clause to force callers to handle it. Since `NetworkTimeoutException` extends `Exception` (not `RuntimeException`), it is a checked exception, and the Java compiler enforces that any method throwing it must declare it with the `throws` keyword followed by the exception type name.

Answer

public void connect() throws RuntimeException

Answer

public void connect() throws e where e is NetworkTimeoutException

Answer

public void connect() throw NetworkTimeoutException

Question 3

A developer writes a catch block that handles multiple exception types that have a subclass relationship. Which of the following is a valid use of the multi-catch feature?

Accepted Answer

catch (IOException e) { ... } catch (SomeOtherUnrelatedException e) { ... }. It demonstrates the proper use of separate catch blocks for unrelated exception types, which is valid. The multi-catch feature (introduced in Java 7) allows catching multiple exception types in a single catch block only if they are not in a parent-child relationship; otherwise, the compiler reports an error due to unreachable code. Since IOException and SomeOtherUnrelatedException are unrelated, separate catch blocks are perfectly valid.

Answer

catch (IOException | FileNotFoundException e) { ... }

Answer

catch (FileNotFoundException | IOException e) { ... }

Answer

catch (IOException e) { ... } catch (FileNotFoundException e) { ... }

Question 4

Consider the following code snippet: 
public int getValue() {
    try {
        return 1;
    } catch (Exception e) {
        return 2;
    } finally {
        return 3;
    }
}
What does the method return?

Accepted Answer

3. (3) because a `finally` block always executes after the `try` block, and if the `finally` block contains a `return` statement, that return value overrides any return value from the `try` or `catch` blocks. In Java, the `finally` block's `return` statement causes the method to exit with the value 3, regardless of what the `try` block attempted to return.

Answer

The code does not compile.

Answer

2

Answer

1

Question 5

A developer is using try-with-resources with a custom resource class that implements AutoCloseable. The class's close() method throws a custom exception `ResourceException`. In the try block, an IOException occurs. Which of the following best describes the exception that is propagated to the caller?

Accepted Answer

The IOException is propagated with the ResourceException added as a suppressed exception.. When using try-with-resources, if both the try block and the close() method throw exceptions, the exception from the try block is the one propagated to the caller, and any exception from close() is added as a suppressed exception to that primary exception. This is specified in Java's try-with-resources semantics (JLS §14.20.3). Therefore, the IOException from the try block is propagated, and the ResourceException from close() is suppressed within it.

Answer

The IOException is discarded and the ResourceException is thrown.

Answer

The IOException is lost and the caller receives no exception.

Answer

Both exceptions are thrown simultaneously as a multi-exception.

Question 6

A developer compiles a Java application using the command `javac -d bin src/com/example/App.java`. Which of the following is true?

Accepted Answer

The compiled .class files are placed in the `bin` directory maintaining the package structure.. The `-d` option in the `javac` command specifies the destination directory for compiled `.class` files. When `-d bin` is used, the compiler places the `.class` files into the `bin` directory, preserving the package directory structure (e.g., `bin/com/example/App.class`). This is the standard behavior for organizing compiled output separately from source code.

Answer

The compiler searches for source files in the `bin` directory.

Answer

The compiler creates a JAR file named `App.jar` in the `bin` directory.

Answer

The compiler compiles the code into a named module.

Question 7

Which TWO of the following are best practices for exception handling in Java?

Accepted Answer

Catch specific exceptions rather than generic Exception or Throwable.. Catching specific exceptions (e.g., IOException, SQLException) allows you to handle each error condition appropriately, rather than using a broad catch-all like Exception or Throwable which can mask unexpected bugs and make code harder to maintain. This follows the principle of precise exception handling, ensuring that only recoverable or expected exceptions are caught, while letting runtime exceptions propagate.

Answer

Always catch Exception in every method to prevent crashes.

Answer

Throw an exception from a finally block to ensure cleanup failures are reported.

Answer

Ignore exceptions by leaving the catch block empty.

Question 8

Which TWO of the following development tools are specifically designed to analyze module dependencies or create custom runtime images?

Accepted Answer

jdeps. The jdeps tool (option A) is a Java class dependency analyzer that examines class files or JARs to identify module-level dependencies, including transitive dependencies, and can suggest module dependencies for migration to the Java module system. The jlink tool (option B) is a Java linker that assembles and optimizes a set of modules and their dependencies into a custom runtime image, allowing you to create a minimal JRE tailored to your application.

Answer

jar

Answer

javadoc

Answer

javac

Question 9

Which THREE of the following are checked exceptions in Java?

Accepted Answer

java.sql.SQLException. `java.sql.SQLException` is a checked exception in Java, meaning it must be either caught or declared in the method signature using `throws`. Checked exceptions are subclasses of `Exception` but not of `RuntimeException`, and `SQLException` directly extends `java.lang.Exception`, making it a checked exception that the compiler enforces handling for.

Answer

java.lang.NullPointerException

Answer

java.lang.ArithmeticException

Question 10

A developer tries to compile a modular Java application using the command shown in the exhibit. The compilation fails with the error shown. What is the most likely cause?

Accepted Answer

The `--module-source-path` does not include the location of the utility module.. The error indicates that the compiler cannot find the utility module referenced in the `requires` directive. The `--module-source-path` option must list all directories containing module source code. Since the utility module's source is not included in the specified path, the compilation fails. Option D correctly identifies this missing path as the cause.

Answer

The `-d out` flag is incorrectly specified; it should point to the source directory.

Answer

The `-m` option should be `--module` instead.

Answer

The import statement should use the fully qualified class name instead of importing.

Question 11

You are a junior developer tasked with generating API documentation for a large Java project. The project uses Javadoc comments extensively, and you need to generate HTML documentation that includes all public and protected classes and methods. You have access to the source files in the `src` directory, and you want the output to be placed in a `docs` folder. Additionally, you want to include a custom header and footer in each generated page. The project uses multiple packages like `com.example.app`, `com.example.util`, and `com.example.data`. You plan to run the javadoc command from the project root. Which command should you use?

Accepted Answer

javadoc -d docs -header 'My App API' -footer 'Copyright 2024' -sourcepath src com.example.app com.example.util com.example.data. It specifies the exact package names (`com.example.app`, `com.example.util`, `com.example.data`) that contain the public and protected classes and methods required for the documentation, uses `-d docs` to set the output directory, and includes `-header` and `-footer` to add custom header and footer text. This command generates HTML documentation for only the specified packages, meeting all requirements.

Answer

Answer

javadoc -d docs -private -sourcepath src com.example.app com.example.util com.example.data

Answer

Question 12

You are maintaining a multi-threaded banking application that processes transactions. In the `processTransaction` method, you have a try-catch block that catches `Exception` to handle any unexpected errors. Recently, the application intermittently fails to update account balances correctly due to unhandled exceptions. The logs show that sometimes a `RuntimeException` is thrown from a nested method, but it is not being logged or handled properly, leading to inconsistent state. The team wants to improve the exception handling to ensure that all exceptions are caught, logged, and the transaction is rolled back properly. The method currently uses a primitive try-catch-finally where the finally block commits the transaction if no exception occurred. Which approach best addresses the issue while maintaining clarity and correctness?

Accepted Answer

Inside the try block, set a boolean success flag to true upon completion; in the finally block, check the flag: if false, rollback; if true, commit. Additionally, catch specific exceptions, log them, and ensure rollback logic is invoked.. Option C is correct because it uses a boolean success flag set inside the try block; the finally block checks the flag to commit only if success, and rolls back otherwise. This ensures the transaction is committed only when no exception occurred. Additionally, catching specific exceptions (including RuntimeException) and logging them provides proper error handling. Option A is wrong because removing the catch block eliminates the ability to log and handle exceptions specifically, even though a boolean flag in finally can manage the commit/rollback. Option B is wrong because even though it adds a catch for RuntimeException and calls rollback, the finally block still unconditionally commits afterward, which can override the rollback. Option D is wrong because declaring throws Exception pushes the rollback responsibility to the caller without resolving the local transaction consistency.

Answer

Remove the `catch (Exception e)` block and rely solely on the finally block to commit or roll back based on a boolean flag set in the try block.

Answer

Add a separate catch block for `RuntimeException` before the existing `catch (Exception e)` and call rollback there, then rethrow the exception.

Answer

Declare the method with `throws Exception` and let the caller handle the transaction rollback.

Question 13

You are responsible for deploying a Java desktop application that uses JavaFX and various third-party libraries. The application is modular and uses JPMS. To reduce the footprint and startup time, you decide to use jlink to create a custom runtime image that includes only the required modules. The application has a main module `com.myapp` that requires `javafx.controls`, `javafx.base`, and some other modules. After creating the runtime image using the command `jlink --module-path $JAVA_HOME/jmods:lib --add-modules com.myapp --output myapp-image`, you test the image on a development machine, and it works. However, when deploying to a customer's machine, the application fails to start with an error: "Error: Could not find or load main class com.myapp.Main". The customer's machine has no Java installed. The runtime image includes the `com.myapp` module. You verify that the `myapp-image/bin/java` launcher exists. The main class is correctly declared in the module-info.java of `com.myapp`. What is the most likely cause of this error?

Accepted Answer

Use the `--launcher` option in jlink to create a launcher script that automatically runs the main class with the correct module.. The `jlink` tool does not automatically create a launcher script that specifies the main class for the runtime image. Without the `--launcher` option, the generated `java` launcher does not know which module and main class to execute, leading to the 'Could not find or load main class' error when no Java is installed on the customer's machine. Using `--launcher` creates a custom script (e.g., `myapp`) that invokes `java --module com.myapp/com.myapp.Main`, ensuring the correct entry point is used.

Answer

Use the `--add-modules` option to include `javafx.controls` and other required modules in the command.

Answer

Add the `--bind-services` option to jlink to automatically include service provider modules.

Answer

Ensure that the `com.myapp` module reads all required modules by adding `requires` directives in module-info.java.

Question 14

A developer is debugging a Java application that throws a NullPointerException. Which two actions help identify the source of the exception? (Choose two.)

Accepted Answer

Use a debugger to step through code. To identify the source of a NullPointerException, the most effective actions are examining the stack trace (option C) and using a debugger (option B). The stack trace shows the exact line number and method call sequence where the exception occurred, pinpointing the location. A debugger allows you to step through code, inspect variable states, and observe the flow leading to the null reference. While System.out.println (A), catching the exception and printing its message (E), and recompiling with -g (D) can provide debugging information, they are not as direct or efficient for locating the root cause; notably, catching the exception does not prevent it and only prints the message without full stack details.

Answer

Use System.out.println statements

Answer

Recompile with -g flag

Answer

Catch the exception and print its message

Question 15

Refer to the exhibit. A developer encounters this exception when running the application. The method divide is intended to handle division by zero. What is the most likely cause of the exception?

Accepted Answer

The divide method uses integer division without checking the divisor.. The exception is ArithmeticException, which occurs when integer division by zero is performed. The stack trace points to line 12 inside the divide method, indicating that the method did not check whether the divisor is zero before performing the division. Option C is correct because using integer division without checking the divisor is the direct cause. Option A is incorrect because ArithmeticException is an unchecked exception, so catching it is not mandatory. Option B is incorrect because the JVM correctly throws the exception; it is not a configuration issue. Option D is incorrect because unchecked exceptions do not need to be declared in a throws clause.

Answer

The divide method does not catch ArithmeticException.

Answer

The JVM is not configured to handle arithmetic exceptions.

Answer

The Main class does not declare throws ArithmeticException.