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

Question 1

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. Option B is correct because 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 2

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) { ... }. Option B is correct because 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 3

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. The correct answer is A (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 4

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 5

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 6

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

Accepted Answer

Catch specific exceptions rather than generic Exception or Throwable.. Option A is correct because 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 7

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 8

Which THREE of the following are checked exceptions in Java?

Accepted Answer

java.sql.SQLException. Option A is correct because `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 9

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 10

You are a Java developer working on an enterprise application that uses a modular architecture with Java Platform Module System (JPMS). The application consists of several modules: `com.app.core`, `com.app.util`, `com.app.service`, and `com.app.client`. The application runs on a server that has Java 17 installed. Recently, the operations team reported that after a deployment, the application fails to start with a `NoClassDefFoundError` for a class in `com.app.util`, even though the class exists in the compiled module. The deployment process uses a custom script that compiles the modules using `javac` with `--module-source-path`, then uses `jlink` to create a custom runtime image that includes only the required modules. The runtime image is then deployed to the server. The build logs show no errors during compilation or linking. However, on the server, the error occurs. The server has multiple versions of the same library on the classpath due to legacy scripts. You suspect that the error is due to a module resolution issue. Which corrective action should you take?

Accepted Answer

Remove any classpath entries from the server startup script and rely exclusively on the module path provided by the runtime image.. Option B is correct because the `NoClassDefFoundError` occurs when the custom runtime image built with `jlink` is deployed, but legacy scripts add classpath entries that cause module resolution conflicts. JPMS requires that all dependencies be on the module path; mixing classpath entries can lead to split packages or incorrect module resolution, resulting in the error. Removing classpath entries ensures the runtime image's module path is used exclusively, resolving the issue.

Answer

Recompile the application without using modules by placing all classes on the classpath instead.

Answer

Ensure that the module `com.app.util` exports the package containing the missing class in its module-info.java.

Answer

Add detailed logging in the module's initialization to trace the class loading and identify where the error originates.

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. Option C is correct because 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: Use a try-catch block specifically for `RuntimeException` (and possibly other checked exceptions) to catch them, log, and roll back, then either rethrow or handle appropriately. The current catch of `Exception` is too broad and may be masking the fact that `RuntimeException` is not being logged because the catch block might not be executed if the exception occurs after the try block's scope? Actually, the issue is that the catch block may be catching but not properly rolling back. But more importantly, the method should not commit if any exception occurs; the finally block should only commit on success. Option A is wrong because adding a separate `RuntimeException` catch before the generic `Exception` catch is syntactically possible but still commits in finally unless rollback is called. Option B is wrong because using a finally block to commit always commits even if an exception occurred, unless you use a flag. Option D is wrong because using `throws` is not a handling strategy; it pushes the problem to the caller without resolving the rollback requirement.

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.. Option B is correct because 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. Examining the stack trace (option A) shows the exact line number where the exception occurred, and using a debugger (option D) allows stepping through code to see variable states. While System.out.println (B) and catching the exception (C) can be helpful, they are less efficient and don't provide the precise location as directly. Recompiling with -g (E) adds debug info but is not an action to identify the source; it's a prerequisite for better stack traces.

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 ArithmeticException is an unchecked exception thrown by the JVM when integer division by zero occurs. The stack trace points to line 12 in Calculator.java, which is inside the divide method. The most likely cause is that the divide method does not check if the divisor is zero before performing division. Option A is incorrect because catching is not mandatory for unchecked exceptions. Option C is incorrect because unchecked exceptions do not need to be declared. Option D is incorrect because the JVM correctly throws the exception; it is not a configuration issue.

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.