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

Question 1

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

Accepted Answer

jdeps. jdeps (A) is correct because it is the Java Dependency Analysis Tool that inspects class files and JARs to report package-level and module-level dependencies, including identifying required modules and internal APIs. jlink (B) is correct because it is the Java Linker tool that assembles a custom runtime image from a set of modules, using the module graph to include only the needed JDK modules. The other options do not fit: jar (C) packages class files and resources into an archive but does not analyze module dependencies or build runtime images; javadoc (D) generates API documentation from source comments; and javac (E) compiles Java source code into bytecode.

Answer

jar

Answer

javadoc

Answer

javac

Question 2

Which THREE of the following are checked exceptions in Java?

Accepted Answer

java.sql.SQLException. java.sql.SQLException (A) is a checked exception because it extends java.lang.Exception (via java.sql.SQLException's hierarchy) and is not a subclass of RuntimeException, so the compiler requires it to be declared or caught. java.lang.ClassNotFoundException (C) is also a checked exception, extending java.lang.ReflectiveOperationException (which extends Exception), and must be handled or declared when using methods like Class.forName(). java.io.IOException (E) is a checked exception extending java.lang.Exception, commonly required to be handled for I/O operations. In contrast, java.lang.NullPointerException (B) and java.lang.ArithmeticException (D) are both subclasses of java.lang.RuntimeException, making them unchecked exceptions that do not require explicit handling.

Answer

java.lang.NullPointerException

Answer

java.lang.ArithmeticException

Question 3

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 4

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. Option B is correct because a debugger lets you set breakpoints and step through the code line by line, inspecting variable values and the call stack at the exact moment the NullPointerException is thrown, which pinpoints the null reference. Option C is correct because the stack trace printed when a NullPointerException is thrown shows the exact class, method, file, and line number where the null dereference occurred, immediately identifying the source. Option A is not ideal because println statements only show whatever you explicitly print and do not reveal the exception's origin or call path. Option D is wrong because the -g flag only adds debugging symbols (line numbers, local variable info) to the compiled class files; it does not itself identify where the exception came from. Option E is insufficient because catching the exception and printing only its message typically yields just 'null' without the stack trace, so the source location remains unknown.

Answer

Use System.out.println statements

Answer

Recompile with -g flag

Answer

Catch the exception and print its message

Question 5

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 most likely an ArithmeticException thrown because the divide method performs integer division without checking if the divisor is zero. In Java, dividing an int by zero throws ArithmeticException at runtime; the method must explicitly check the divisor or catch the exception. Since the method is 'intended to handle division by zero' but still throws, the cause is the missing divisor check.

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.

Question 6

A developer writes a method that parses a user-supplied string into an int using Integer.parseInt. The method must signal to its caller that parsing may fail with a NumberFormatException, but the developer wants callers to be forced to handle or declare it. Which change should the developer make to the method signature?

Accepted Answer

Wrap the parseInt call in a try-catch block and throw a new checked exception, declaring that checked exception in the method signature.. Unchecked exceptions such as NumberFormatException are not subject to the catch-or-declare requirement, so merely declaring it does not force callers to handle it. To impose that requirement, the method must throw a checked exception instead, which the compiler then enforces. Wrapping the parse call and throwing a checked exception, with that exception declared in the signature, is the only listed change that accomplishes this.

Answer

Declare the method with a generic type parameter bound to Exception.

Answer

Annotate the method with @Override to indicate it may throw an exception.

Answer

Add throws NumberFormatException to the method signature.

Question 7

A developer is writing a Java class that must open a network socket to a remote server. The code compiles successfully, but the developer is confused because the compiler requires the method to declare a throws clause or wrap the socket creation in a try-catch block. Which statement best explains why the compiler imposes this requirement?

Accepted Answer

The Socket constructor declares that it throws IOException, which is a checked exception, so the compiler enforces handling or declaring it.. The Socket constructor explicitly declares throws IOException. Because IOException is a checked exception, the compiler mandates that any calling code either catches it or declares it. The other options incorrectly attribute the requirement to abstract classes, unchecked exceptions, or a package-wide rule, none of which apply here.

Answer

The Socket constructor throws a RuntimeException, and the compiler requires all RuntimeExceptions to be declared.

Answer

The Socket class is abstract, and abstract classes always force checked exception handling in their subclasses.

Answer

All methods in the java.net package are required by the Java Language Specification to declare throws IOException.

Question 8

A developer writes the following code:

public class Test {
    public static void main(String[] args) {
        try {
            throw new RuntimeException("A");
        } catch (Exception e) {
            System.out.print("B");
        } finally {
            System.out.print("C");
        }
    }
}

What is printed?

Accepted Answer

BC. The thrown RuntimeException is a subclass of Exception, so the catch block handles it and prints B. The finally block executes regardless of whether an exception is caught, printing C. The exception message "A" is never printed. Thus the program outputs BC.

Answer

C

Answer

B

Answer

ABC

Question 9

A developer is writing a Java application that must terminate immediately when a critical configuration error occurs, without printing a stack trace or allowing any finally blocks to execute. Which statement should the developer use?

Accepted Answer

System.exit(1);. System.exit(int) halts the JVM at the point of invocation. Because the JVM shuts down before returning from the call, finally blocks associated with any active try statements do not execute, and no uncaught-exception stack trace is produced. This makes it the appropriate choice when a program must stop immediately on a fatal configuration error.

Answer

throw new RuntimeException("Configuration error");

Answer

assert false : "Configuration error";

Answer

return;

Question 10

A developer wants to compile and run a Java program from the command line. The source file is named Hello.java and contains a single public class Hello. Which command correctly compiles the source file?

Accepted Answer

javac Hello.java. The Java compiler is invoked with the javac command, which takes source file names including the .java extension. The java command is used to run compiled classes. Therefore, javac Hello.java is the correct way to compile the source file into bytecode.

Answer

javac Hello

Answer

java Hello.class

Answer

java Hello.java

Question 11

A developer compiles a Java source file with the command `javac -d classes src/com/example/App.java`. The compilation succeeds. Where is the resulting `App.class` file placed?

Accepted Answer

In `classes/com/example/App.class`, with the package directory structure created under `classes`.. When javac is invoked with -d, it treats the argument as the root of the output directory tree and mirrors the package name as subdirectories. For a source file declaring package com.example, the compiler creates classes/com/example and writes App.class inside it, keeping the class file location consistent with the fully qualified class name.

Answer

In `src/com/example/App.class`, alongside the source file.

Answer

In the current working directory.

Answer

In `classes/App.class`, directly under `classes` without package subdirectories.

Question 12

A developer writes a method that may throw a checked exception and wants to document the exception for callers. Which two statements about the `throws` clause are correct? (Choose two.)

Accepted Answer

A method can declare multiple checked exceptions in its throws clause, separated by commas.. The throws clause lists checked exceptions that a method might propagate to its caller, and it may contain several types separated by commas. Declaring an exception does not force the method to throw it, because the clause defines a caller-facing contract. Overriding methods, however, may only narrow the checked exceptions declared by the overridden method, never add new ones.

Answer

A throws clause must list every exception that the method body can possibly throw, including unchecked ones.

Answer

A method that overrides a superclass method may declare additional checked exceptions not declared by the overridden method.

Answer

Only unchecked exceptions can appear in a throws clause.

Question 13

A developer is debugging a Java application and wants to pause execution at a specific line in a method without modifying the source code. Which Java Development Kit tool allows setting a breakpoint at a class and line number before launching the program?

Accepted Answer

jdb. jdb is the JDK's command-line debugger. It attaches to or launches a Java program and supports commands that set breakpoints by class and line number, inspect variables, and step through execution. This allows a developer to pause at a specific line without editing the source, which is exactly what the scenario requires.

Answer

javap

Answer

jcmd

Answer

jconsole

Question 14

A developer is writing a method that catches multiple exception types in a single catch block using the multi-catch feature. The catch clause is: catch (IOException | SQLException e) { ... }. Which statement is true about the variable e in this catch block?

Accepted Answer

The variable e is implicitly final and cannot be reassigned within the catch block.. In a multi-catch clause, the exception parameter is implicitly final. This means it cannot be reassigned within the catch block. This restriction is enforced by the compiler to maintain type safety and to allow the compiler to generate efficient bytecode. The variable's type is the least upper bound of the caught types, and only methods available on that type can be called.

Answer

The variable e is of type Exception, so you can call any method defined in Exception.

Answer

The variable e can be used to rethrow the exception, but only if the method declares throws for both IOException and SQLException.

Answer

The variable e can be reassigned to a new exception object of any type.

Question 15

A method declares `public void parse(String input) throws IOException`. Inside the method body, the code calls another method that declares `throws IOException` but does not throw it in every execution path. A reviewer asks the developer to document the method contract without changing behavior. Which statement best describes the effect of the `throws IOException` clause in the method signature?

Accepted Answer

It forces every caller of `parse` to handle or declare `IOException`, regardless of whether an exception is actually thrown at runtime.. The `throws` clause is a compile-time declaration that a method may propagate a checked exception. It obligates callers to catch or declare that exception, but it does not force the exception to occur at runtime. The declaration documents the method contract and is enforced by the compiler, not by runtime checks.

Answer

It guarantees that `parse` will throw `IOException` at least once during every execution.

Answer

It converts `IOException` into an unchecked exception for callers of `parse`.

Answer

It allows callers to ignore `IOException` because the method declares it explicitly.