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

Question 1

A developer needs to handle a specific checked exception, FileNotFoundException, but also wants to catch any other IOException that might occur. Which catch block ordering is correct?

Accepted Answer

catch (FileNotFoundException e) first, then catch (IOException e).. Checked exceptions must be caught in order from most specific to most general. FileNotFoundException is a subclass of IOException, so it must be caught first; otherwise, the more specific catch block would be unreachable and cause a compilation error. This ordering ensures that the developer can handle the specific FileNotFoundException separately while still catching any other IOException in the second block.

Answer

Use a multi-catch: catch (FileNotFoundException | IOException e).

Answer

catch (IOException e) first, then catch (FileNotFoundException e).

Answer

Use a single catch (Exception e).

Question 2

A developer is using the Oracle Java Platform Debugger Architecture (JPDA) to debug a remote Java application. Which command-line option is required to start the application in debug mode listening on port 5005?

Accepted Answer

-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005. The `-agentlib:jdwp` option is the modern, recommended way to enable the Java Debug Wire Protocol (JDWP) for remote debugging. It specifies the transport as `dt_socket` (TCP/IP sockets), sets the JVM as the debug server (`server=y`), does not suspend the application on startup (`suspend=n`), and listens on port 5005 (`address=5005`). This is the standard JPDA configuration for attaching a debugger to a running Java application.

Answer

-javaagent:debug.jar=port=5005

Answer

-Xdebug -Xrunjdwp:transport=dt_socket,server=y,address=5005

Answer

-Ddebug=true -Dport=5005

Question 3

A Java application uses a custom exception class that extends Exception. The application throws this exception from a method, but the method does not declare it in its throws clause. Which statement is true?

Accepted Answer

The code will not compile because checked exceptions must be declared.. In Java, a custom exception class that extends Exception (but not RuntimeException) is a checked exception. Checked exceptions must be either caught within the method using a try-catch block or declared in the method's throws clause. If the method throws a checked exception without declaring it, the code will not compile. This is enforced by the Java compiler to ensure that callers are aware of and handle potential exceptions.

Answer

The code will compile only if the exception is caught inside the method.

Answer

The code will compile and throw a RuntimeException if the exception occurs.

Answer

The code will compile because custom exceptions are unchecked.

Question 4

Which tool is used to generate documentation comments from Java source code?

Accepted Answer

javadoc. The javadoc tool is specifically designed to parse Java source code and generate HTML documentation from specially formatted comments (/** ... */). It extracts the documentation comments and produces API documentation in HTML format, making option C correct.

Answer

javac

Answer

java

Answer

jar

Question 5

A developer encounters a ClassNotFoundException at runtime. The class is present in the source code and compiles fine. Which is the most likely cause?

Accepted Answer

The classpath does not include the directory or JAR containing the .class file.. A ClassNotFoundException occurs when the Java Virtual Machine (JVM) cannot locate the .class file for a referenced class at runtime, even though the source code compiled successfully. Since the class compiles fine, the issue is not with the source code but with the runtime environment — specifically, the classpath does not include the directory or JAR file that contains the compiled .class file. The JVM uses the classpath to search for class files during class loading, and if the path is missing, it throws ClassNotFoundException.

Answer

The class is in the wrong package.

Answer

The class is abstract.

Answer

The class has a static initializer that fails.

Question 6

Given the following try-catch block:
try {
    // some code
} catch (IOException | NumberFormatException e) {
    e = new IOException("wrapper");
    // throw e;
}
Which line causes a compilation error?

Accepted Answer

The assignment to e. In a multi-catch block, the exception parameter `e` is implicitly `final` and cannot be reassigned. The assignment `e = new IOException("wrapper")` violates this rule, causing a compilation error at that line.

Answer

The multi-catch syntax

Answer

No error

Answer

The throw statement

Question 7

Which TWO statements are true about the finally block in exception handling? (Select exactly 2)

Accepted Answer

The finally block is executed even if the try block contains a return statement.. Option D is correct because the finally block is guaranteed to run even when the try block executes a return statement; the JVM evaluates the return value, then runs the finally block before actually returning (and a return inside finally would override it). Option E is correct because the finally block executes after the try block and after any catch block that handled an exception, but before control returns to the caller, ensuring cleanup code runs on all exit paths. Option A is wrong because finally runs whether or not an exception is thrown, not only when one occurs. Option B is wrong because omitting finally is unrelated to checked exceptions; a try can legally have only a finally (no catch), and try-with-resources or catch blocks handle checked exceptions independently. Option C is wrong because finally also executes when an exception is thrown and caught, or propagates, not only when no exception occurs.

Answer

The finally block is executed only if an exception is thrown.

Answer

The finally block can be omitted only if the try block does not throw any checked exception.

Answer

The finally block is executed only if no exception is thrown.

Question 8

Which TWO command-line tools are included in the Oracle JDK for monitoring and troubleshooting Java applications? (Select exactly 2)

Accepted Answer

jstack. jstack (A) is a JDK troubleshooting tool that prints Java thread stack traces, including locks and deadlock detection, for a running JVM, making it a core monitoring/diagnostic utility. jstat (C) is also a JDK monitoring tool that reports JVM statistics such as garbage collection, class loading, and JIT compilation performance via the jstatd/PerfData interface. jmod (B) is a packaging tool for creating and inspecting JMOD files, not for runtime monitoring. javap (D) is a class-file disassembler used to inspect bytecode and signatures, not to monitor a live JVM. jdb (E) is the Java Debugger for interactive debugging sessions, not a monitoring/troubleshooting statistics tool.

Answer

jmod

Answer

javap

Answer

jdb

Question 9

Which THREE statements about custom exceptions in Java are correct? (Select exactly 3)

Accepted Answer

A checked custom exception must be declared in the throws clause of any method that throws it.. Option A is correct because a checked exception (any subclass of Exception that is not a subclass of RuntimeException) is subject to the Java checked-exception rule, so any method that throws it must declare it in its throws clause or the code will not compile. Option B is correct because a custom exception can be designed as either checked (extending Exception) or unchecked (extending RuntimeException), giving the developer control over whether callers are forced to handle it. Option C is correct because the defining characteristic of an unchecked exception in Java is that it extends RuntimeException (or one of its subclasses), so an unchecked custom exception must extend RuntimeException. Option D is incorrect because a custom exception need not extend Throwable directly; it typically extends Exception or RuntimeException, which already inherit from Throwable. Option E is incorrect because custom exceptions can and commonly do define constructors that call super(...) to pass messages or causes to the parent class.

Answer

A custom exception class must directly extend Throwable.

Answer

A custom exception cannot have constructors that call super.

Question 10

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?

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 11

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 12

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 13

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 14

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 15

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 exception types (e.g., IOException, SQLException) rather than generic Exception or Throwable lets the code handle each failure appropriately and avoids accidentally swallowing unrelated runtime errors, which is a widely recognized Java best practice. Option C is correct because try-with-resources automatically invokes close() on any resource implementing AutoCloseable (or its subinterface Closeable), guaranteeing deterministic cleanup and suppressing secondary exceptions via addSuppressed(), which is the recommended pattern over manual finally blocks. Option B is wrong because blanket-catching Exception in every method hides bugs, breaks checked-exception contracts, and prevents callers from handling failures meaningfully. Option D is wrong because throwing from a finally block discards or masks any exception propagating from the try or catch block, producing confusing stack traces and is explicitly discouraged. Option E is wrong because an empty catch block silently swallows exceptions, losing diagnostic information and leaving the program in an inconsistent state.

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.