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

Question 1

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?

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

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 2

A developer is maintaining a Java backend service for order processing. The service uses a third-party library that throws a checked PaymentException when a payment fails. The current processOrder method catches Exception generically, logs the error, and returns null. The business requires that when a payment fails, the order status must be updated to 'FAILED' in the database, and a notification must be sent to the customer. However, due to the generic catch, these actions are not performed. The developer must modify the code to meet the business requirements without changing the external API of the class (i.e., the method signature must remain the same and must not throw any exceptions to the caller). Which course of action should the developer take?

Accepted Answer

In the catch block, check if the exception is an instance of PaymentException, then update the order status and send notification. Do not rethrow the exception.. The correct approach is Option D. The current code catches Exception generically, which prevents the specific handling of PaymentException. Option D catches Exception, checks if it is an instance of PaymentException, updates the order status and sends notification, and then does not rethrow the exception. This satisfies the business requirements without changing the method signature or propagating any exception to the caller. Option A is incorrect because rethrowing a RuntimeException still propagates an exception. Option B is incorrect because declaring throws Exception propagates the checked exception. Option C is incorrect because a finally block would execute even on success, leading to incorrect notifications and status updates.

Answer

Catch PaymentException specifically, update the order status and send notification, then throw a new RuntimeException to indicate failure.

Answer

Remove the try-catch block and declare the method with throws Exception, allowing the caller to handle payment failures.

Answer

Use a finally block to update the order status and send notification regardless of success or failure.

Question 3

A developer is using the javadoc tool to generate HTML documentation for a package. The source files contain doc comments with @param, @return, and @throws tags. After running javadoc, the developer notices that the @throws tag for a method is missing from the generated output. Which is the most likely cause?

Accepted Answer

The @throws tag was placed after the method's closing brace instead of inside the doc comment.. Javadoc processes tags only when they appear inside a doc comment that directly precedes the declaration. A tag placed outside the comment block, such as after the method's closing brace, is treated as ordinary text or ignored. Ensuring the @throws tag is inside the comment, before the method signature, is the correct fix for the missing documentation.

Answer

The javadoc tool does not support @throws for methods that declare checked exceptions.

Answer

The @throws tag must be written as @exception to appear in the output.

Answer

The exception class named in the @throws tag is not imported in the source file.

Question 4

A developer runs a Java application from the command line with the command: java -cp lib/* com.example.Main. The application throws a NoClassDefFoundError at runtime for a class that is inside a JAR located in the lib directory. The JAR file name is mylib.jar. Which is the most likely cause of the error?

Accepted Answer

The JAR file mylib.jar is not on the classpath because the wildcard * must be escaped or quoted in the shell, and it was expanded by the shell instead of the JVM.. The classpath wildcard * is expanded by the shell on many systems before the JVM receives the argument. If the shell expands it, the JVM sees a list of files in the current directory instead of lib/*, so the JAR is never added to the classpath. Quoting the argument or using an explicit JAR path ensures the JVM resolves the wildcard correctly.

Answer

The class com.example.Main is not public, so the JVM cannot load it even though it is on the classpath.

Answer

The classpath wildcard * does not expand to include JAR files; it only matches class files in directories.

Answer

The JAR file mylib.jar is corrupted, so the JVM cannot read the class file inside it.

Question 5

A developer is compiling a Java project with the command `javac -d build src/com/example/App.java`. The compilation succeeds and class files appear under the `build` directory. A colleague later runs `java -cp build com.example.App` from the project root and receives `Error: Could not find or load main class com.example.App`. The class file exists at `build/com/example/App.class`. Which is the most likely cause of the runtime error?

Accepted Answer

The `com.example.App` class does not declare a `public static void main(String[] args)` method.. The launcher first locates the class through the classpath, then checks for a valid `public static void main(String[] args)` entry point. When that method is missing, the JVM reports that it could not find or load the main class, even though the `.class` file exists. The other explanations involve classpath or version issues that would produce different error messages.

Answer

The `build` directory must be added to the `PATH` environment variable for the JVM to locate the class.

Answer

The `-cp build` option is ignored because the classpath must be set with the `CLASSPATH` environment variable only.

Answer

The source file was compiled with a newer JDK than the one used to run the program.

Question 6

A developer runs a Java application and sees a stack trace that begins with `java.lang.NullPointerException: Cannot invoke "String.length()" because "name" is null`. The application compiles without errors. Which action best helps the developer locate the exact source line that triggered the exception?

Accepted Answer

Recompile the application with the `-g` option and run it again to obtain line numbers in the stack trace.. Line numbers in stack traces come from debugging information embedded at compile time. The `-g` option makes `javac` include line numbers, local variable tables, and source file information. Without it, the trace may lack the exact line, making the null dereference harder to locate. The other options do not add the missing source location data.

Answer

Add a `catch (NullPointerException e)` block around the entire `main` method to print the exception again.

Answer

Use `javap -c` on the compiled class to disassemble the bytecode and manually map the failing instruction to a source line.

Answer

Run the application with `java -ea` to enable assertions that check for null values.

Question 7

Which of the following is the best practice for resource management in Java?

Accepted Answer

Use try-with-resources statement.. The try-with-resources statement (introduced in Java 7) automatically closes each resource declared in its header when the block exits, whether normally or due to an exception. This eliminates the need for explicit cleanup code and ensures that resources implementing `AutoCloseable` are closed reliably, preventing resource leaks.

Answer

Close resources in a finally block without null checks.

Answer

Rely on garbage collection to close resources.

Answer

Use a try-catch block and close resources in the catch block.

Question 8

A developer encounters an ArrayIndexOutOfBoundsException while running a unit test. The stack trace shows the error occurs in a method that is called from many places. Which tool or technique would most efficiently identify the specific call path?

Accepted Answer

Set a breakpoint in the method and debug the test.. Setting a breakpoint in the method and debugging the test allows the developer to inspect the call stack at runtime, immediately revealing the exact sequence of method invocations that led to the ArrayIndexOutOfBoundsException. This is the most efficient approach because it directly captures the specific call path without requiring manual tracing or post-hoc analysis.

Answer

Review the code manually to trace all possible callers.

Answer

Run a static analysis tool to detect the issue.

Answer

Add log statements at the beginning of the method.

Question 9

Which statement about the Java compiler is true?

Accepted Answer

It translates Java source code into bytecode.. The Java compiler (javac) translates human-readable Java source code (.java files) into platform-independent bytecode (.class files). This bytecode is then executed by the Java Virtual Machine (JVM), not directly by the operating system. Option D correctly identifies this translation step.

Answer

It translates Java source code into native machine code.

Answer

It produces executable files that run directly on the OS.

Answer

It executes Java programs.

Question 10

Which command is used to run a Java application from the command line?

Accepted Answer

java. The `java` command is the correct tool to launch a Java application from the command line. It invokes the Java Virtual Machine (JVM) to load and execute the compiled bytecode contained in `.class` files or a JAR file. Without this command, the application cannot run.

Answer

jar

Answer

javac

Answer

javadoc

Question 11

Which TWO statements about the finally block are true? (Choose two.)

Accepted Answer

A try block must be followed by either a catch or finally.. Option A is correct because Java's grammar requires that a try block be accompanied by at least one catch clause or a finally clause (or both); a try with neither is a compile-time error. Option C is correct because the finally block is the standard place to release resources such as files, sockets, or database connections, since it runs regardless of whether an exception occurs, ensuring cleanup code is not skipped. Option B is wrong because finally executes whether or not an exception is thrown, including on normal completion of the try block. Option D is wrong because a finally block may legally contain a return statement (though doing so can suppress exceptions or override prior returns). Option E is wrong because finally runs after the try (and after any catch that handled the exception), not specifically after the catch block, and it also runs when no catch block exists.

Answer

The finally block executes only if an exception is thrown.

Answer

The finally block cannot contain a return statement.

Answer

The finally block is executed after the catch block.

Question 12

Which THREE are checked exceptions in Java? (Choose three.)

Accepted Answer

SQLException. B, SQLException, is a checked exception because it extends java.lang.Exception (not RuntimeException) and the compiler requires callers to catch or declare it when using JDBC operations. D, IOException, is the canonical checked exception for I/O failures and must be handled or declared via throws. E, FileNotFoundException, is a subclass of IOException and therefore also checked, requiring explicit handling when opening files. The unmarked options do not belong because A, ArrayIndexOutOfBoundsException, and C, NullPointerException, are both subclasses of RuntimeException, making them unchecked exceptions that the compiler does not force you to catch or declare.

Answer

ArrayIndexOutOfBoundsException

Answer

NullPointerException

Question 13

Given the stack trace above, which line in MyClass.java caused the exception?

Exception in thread "main" java.lang.NullPointerException
    at MyClass.methodC(MyClass.java:25)
    at MyClass.methodB(MyClass.java:15)
    at MyClass.methodA(MyClass.java:10)
    at MyClass.main(MyClass.java:30)

Accepted Answer

Line 25. The stack trace displayed in the question shows the exception was thrown at line 25 of MyClass.java. The topmost line in a stack trace indicates the exact line where the exception originated. Lines 10, 15, and 30 correspond to caller methods that appear lower in the stack trace, making line 25 the correct answer.

Answer

Line 30

Answer

Line 10

Answer

Line 15

Question 14

You are a Java developer at a financial firm. The application processes transactions from a queue. The team recently migrated from Java 8 to Java 11. After the migration, the application intermittently throws an exception: 'java.lang.reflect.InaccessibleObjectException: Unable to make field private final byte[] java.lang.String.value accessible: module java.base does not 'opens java.lang' to unnamed module'. This error occurs when the application tries to use reflection to access private fields of String objects for serialization. The application runs on a server where you cannot modify the JVM startup scripts. However, you can modify the application code and the module-info.java file. You need to resolve the exception without breaking existing functionality. Which approach should you take?

Accepted Answer

Refactor the code to use public APIs instead of reflecting on String's internal fields.. The root cause is that the application uses reflection to access private fields of java.lang.String, which is prohibited in Java 9+ by default due to module system encapsulation. Refactoring to use public APIs (e.g., String.getBytes(), String.charAt()) eliminates the need for reflection entirely, resolving the InaccessibleObjectException without requiring JVM flags or module declarations, and preserves compatibility with Java 11.

Answer

Add --add-opens java.base/java.lang=ALL-UNNAMED to the JVM command line.

Answer

Use sun.misc.Unsafe to access the String field directly.

Answer

Add 'opens java.lang;' to the module-info.java file.

Question 15

Arrange the steps to use a for loop to iterate over an array in Java in the correct order.

Accepted Answer

1. Declare and initialize the array. 2. Write a for loop with initialization, condition, and increment statements. 3. Access elements using array[index] inside the loop. 4. Execute desired operations on each element.. First set up the array, then write a for loop with proper syntax, access elements using index, execute body, and consider enhanced for.

Answer

1. Write a for loop header with initialization, condition, and increment. 2. Declare and initialize the array inside the loop. 3. Access elements using array[index]. 4. Perform operations.

Answer

1. Access array elements using index. 2. Declare and initialize the array. 3. Write a for loop to iterate. 4. Perform operations.

Answer

1. Declare and initialize the array. 2. Perform operations on array elements without a loop. 3. Write a for loop later. 4. Access elements using index.