Exception Handling and Development Tools practice questions

The -cp option is misspelled.

Why wrong: The syntax is correct; the issue is that the path does not exist.

The destination directory bin does not exist.

Why wrong: The error is about the classpath, not the destination directory. javac creates the directory if needed.

The source file has syntax errors.

Why wrong: Syntax errors would be reported as errors, not as a path warning.

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

Why wrong: This would break the modular design and might still have class conflicts from legacy JARs; it is not a proper fix.

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

Why wrong: If the class were not exported, the error would be an IllegalAccessError, not NoClassDefFoundError. The module already exports the package because it compiles and links without issues.

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

Why wrong: While logging helps diagnose, it does not resolve the underlying classpath contamination.

RuntimeException

Why wrong: RuntimeException is unchecked; the caller is not forced to handle it.

Exception

Why wrong: Exception is too general; should use a more specific subclass.

IOException

Why wrong: IOException is broader than needed; FileNotFoundException is more specific.

Ignore the exception because it is not declared.

Why wrong: The compiler will force handling of checked exceptions.

Declare the library's exception in the method signature.

Why wrong: The exception is not declared in the library method, so the compiler won't allow it.

Catch the exception and log it, then continue execution.

Why wrong: This may hide the error and might not be appropriate if the error is fatal.

Close resources in a finally block without null checks.

Why wrong: Null checks are needed to avoid NullPointerException.

Rely on garbage collection to close resources.

Why wrong: Garbage collection does not close resources like streams.

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

Why wrong: Resources should be closed in finally or by try-with-resources.

Review the code manually to trace all possible callers.

Why wrong: This is time-consuming and error-prone.

Run a static analysis tool to detect the issue.

Why wrong: Static analysis cannot reproduce the exact runtime call path.

Add log statements at the beginning of the method.

Why wrong: This requires code changes and recompilation.

It translates Java source code into native machine code.

Why wrong: The compiler outputs bytecode, not machine code.

It produces executable files that run directly on the OS.

Why wrong: Bytecode requires JVM to run.

It executes Java programs.

Why wrong: Execution is done by JVM.

Ignore the exception since it is checked.

Why wrong: Checked exceptions must be handled or declared.

Add a throws clause to the calling method.

Why wrong: This does not handle the exception; it propagates it.

Use a finally block without catch.

Why wrong: Finally does not handle exceptions.

jar

Why wrong: jar is for archiving.

javac

Why wrong: javac is the compiler.

javadoc

Why wrong: javadoc generates documentation.

The finally block executes only if an exception is thrown.

Why wrong: Incorrect. The finally block always executes (unless the JVM exits), not only when an exception is thrown.

The finally block cannot contain a return statement.

Why wrong: Incorrect. The finally block can contain a return statement, though it may suppress exceptions.

The finally block is executed after the catch block.

Why wrong: Incorrect. The finally block executes after the catch block only if a catch block is present and invoked. If no exception occurs, there is no catch block.

ArrayIndexOutOfBoundsException

Why wrong: It is a RuntimeException (unchecked).

NullPointerException

Why wrong: It is a RuntimeException (unchecked).

Line 30

Why wrong: Not mentioned in the stack trace.

Line 10

Why wrong: Line 10 is in Main.java, not the source of the exception.

Line 15

Why wrong: Not mentioned in the stack trace.

Add a throws FileNotFoundException clause to the main method.

Why wrong: Adding a throws clause is a valid way to handle a checked exception, but it does not resolve the compilation error if the calling method (e.g., main) must handle the exception internally. In many exam contexts, try-catch is the preferred fix.

Change FileReader to BufferedReader.

Why wrong: Changing FileReader to BufferedReader does not address the FileNotFoundException because BufferedReader still requires a FileReader or similar that throws the exception.

Use FileInputStream instead.

Why wrong: Using FileInputStream would also throw FileNotFoundException, so it does not resolve the compilation error.

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

Why wrong: You cannot modify JVM startup scripts per the scenario.

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

Why wrong: Unsafe still requires reflection and is not a solution.

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

Why wrong: You cannot open java.lang from your module; it's a system module.

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.

Why wrong: This is incorrect because the array must be declared and initialized before the loop, not inside the loop body. The loop references the array, so it must exist prior.

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

Why wrong: This is incorrect because you cannot access elements before the array is declared, and the loop structure is needed to control the index progression. Operations depend on element access.

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.

Why wrong: This is incorrect because performing operations without a loop on all elements would require repetitive code, and writing the loop after using elements is logically backwards. The loop should come before element access in the iteration context.

static: Declares a method that cannot be overridden

Why wrong: Incorrect — this describes 'final' for methods, not 'static'.

final: Belongs to the class rather than instances

Why wrong: Incorrect — this describes 'static', not 'final'.

A throws declaration in the method signature

Why wrong: throws only propagates the exception, does not close resources.

A finally block without any resource declaration

Why wrong: Finally alone does not automatically close resources.

A try-catch-finally block with explicit close in finally

Why wrong: Explicit close might be missed if not properly written.

ArrayIndexOutOfBoundsException

Why wrong: ArrayIndexOutOfBoundsException is an unchecked exception.

ArithmeticException

Why wrong: ArithmeticException is an unchecked exception (RuntimeException subclass).

NullPointerException

Why wrong: NullPointerException is an unchecked exception.

The caller must catch only FileNotFoundException.

Why wrong: Both exceptions must be handled or declared.

The caller can declare throws Exception to cover both.

Why wrong: Declaring throws Exception is allowed but not the only option; also, it's not a must.

The caller can ignore both exceptions.

Why wrong: Checked exceptions must be handled or declared.

The exception is caught and handled by the finally block.

Why wrong: finally does not catch exceptions; it's for cleanup.

The finally block does not execute if an exception occurs.

Why wrong: finally always executes unless JVM exits.

The method exits immediately without executing finally.

Why wrong: finally executes even on exception.