1Z0-811 Practice Test 28 — 15 Questions

Question 1

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?

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

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 2

Which two of the following are primitives in Java? (Choose two.)

Accepted Answer

byte. Options A and B are correct because byte and char are both Java primitive types: byte is an 8-bit signed two's-complement integer, and char is a 16-bit unsigned Unicode character type, both defined by the Java language as primitives. The remaining options do not belong: String is a class in java.lang (a reference type, not a primitive), Integer is a wrapper class in java.lang that boxes the primitive int, and Boolean is a wrapper class that boxes the primitive boolean — note that the primitive is spelled boolean (lowercase), while Boolean (capitalized) is the wrapper class.

Answer

String

Answer

Integer

Answer

Boolean

Question 3

In the Java memory model, where are primitive local variables declared inside a method stored?

Accepted Answer

Stack. In the Java memory model, primitive local variables declared inside a method are stored on the stack. Each thread has its own stack, and each method invocation creates a stack frame that holds local variables, including primitives and object references. This is distinct from objects themselves, which are allocated on the heap.

Answer

Heap

Answer

Native method area

Answer

Method area

Question 4

What is the output of: int i = 1; i = i++; System.out.println(i);

Accepted Answer

1. In Java, the expression `i = i++` uses the post-increment operator, which first stores the current value of `i` (1) for the assignment, then increments `i` to 2, but the stored original value (1) is then assigned back to `i`. Thus, `i` remains 1, and the output is 1.

Answer

Compilation fails

Answer

0

Answer

2

Question 5

A developer writes: char c = 'A'; int i = c + 1; System.out.println(i); What is the output?

Accepted Answer

66. In Java, when a `char` is involved in arithmetic with an `int`, the `char` is promoted to its Unicode/ASCII numeric value. 'A' has the ASCII value 65, so `c + 1` becomes 66. The result is an `int`, and `System.out.println(i)` prints the integer 66.

Answer

B

Answer

Compilation error: cannot add char and int.

Answer

'A1'

Question 6

A developer writes a method that reads a file and parses its contents. Which exception handling approach is best practice for ensuring the file is properly closed even if an exception occurs?

Accepted Answer

Use a try-with-resources statement.. The try-with-resources statement automatically closes any resource that implements AutoCloseable (such as FileReader or BufferedReader) at the end of the statement, regardless of whether an exception occurs. This eliminates the risk of resource leaks and is the recommended best practice in Java for handling resources that must be closed.

Answer

Use a throws clause and let the caller handle closing.

Answer

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

Answer

Use a try-catch block and close the resource in the finally block.

Question 7

A subclass overrides a method from its superclass. Which annotation should be used to indicate the overriding intention?

Accepted Answer

The @Override annotation is optional but recommended. The @Override annotation is optional in Java; the compiler will still enforce method overriding without it. However, it is strongly recommended because it provides a compile-time check that the method correctly overrides a superclass method, preventing accidental overloading or typos in the method signature.

Answer

The @Override annotation is not allowed

Answer

The @Override annotation is used for overloading

Answer

The @Override annotation is mandatory

Question 8

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 9

A company wants to develop a Java application that can run on Windows, Linux, and macOS without any code changes. Which Java feature makes this possible?

Accepted Answer

Platform Independence via JVM. Java achieves platform independence through the JVM: source code is compiled to bytecode (.class files), which is platform-neutral, and each platform (Windows, Linux, macOS) has its own JVM implementation that interprets or JIT-compiles that bytecode to native instructions. This 'write once, run anywhere' capability is the core Java feature that lets the same compiled application run unchanged across operating systems.

Answer

Multithreading

Answer

Garbage Collection

Answer

Object-Oriented Programming

Question 10

What is the output of the following code? String s1 = "Hello"; String s2 = "Hello"; System.out.println(s1 == s2);

Accepted Answer

true. When two String literals with the same content are assigned to variables, Java reuses the same object from the string pool. Thus s1 and s2 both reference the identical String object, and the == operator, which compares references, returns true. The output is true.

Answer

Hello

Answer

Compilation error

Answer

false

Question 11

What is the cause of the compilation error?

Accepted Answer

The value 200 exceeds the range of byte (-128 to 127). The code attempts to assign the integer literal 200 to a variable of type byte. In Java, the byte data type has a range from -128 to 127. Since 200 exceeds this range, the compiler detects a possible loss of precision and raises a compilation error. Java does not automatically narrow a larger integer literal to fit into a byte without an explicit cast.

Answer

The literal 200 is a long

Answer

The assignment operator is invalid

Answer

The variable b is not declared

Question 12

Given an array arr of length 5, which code snippet correctly creates a copy using System.arraycopy?

Accepted Answer

int[] copy = new int[arr.length]; System.arraycopy(arr, 0, copy, 0, arr.length);. It first declares and initializes a destination array `copy` of the same length as `arr`, then calls `System.arraycopy(arr, 0, copy, 0, arr.length)` to copy all 5 elements from `arr` into `copy`. This is the only option that uses `System.arraycopy` correctly, as the method requires a pre-existing destination array.

Answer

System.arraycopy(arr, 0, copy, 0, arr.length);

Answer

int[] copy = Arrays.copyOf(arr, arr.length);

Answer

int[] copy = arr.clone();

Question 13

A developer writes the following code: for (int i = 0; i < 5; i++) { for (int j = i; j < 5; j++) { System.out.print(j); } } How many times does the inner loop execute in total?

Accepted Answer

15. The outer loop runs with i from 0 to 4 (5 iterations). For each i, the inner loop runs from j = i to j < 5, so the number of inner iterations is 5 - i. Summing these: 5 + 4 + 3 + 2 + 1 = 15. Thus, the inner loop executes 15 times in total.

Answer

5

Answer

10

Answer

20

Question 14

Which operator is used to compare two values for equality in Java?

Accepted Answer

==. The == operator in Java is used to compare two primitive values for equality, returning true if they are equal. For reference types, == compares object references (memory addresses), not the actual content. This is a fundamental operator defined in the Java Language Specification (JLS §15.21) for equality testing.

Answer

equals()

Answer

!=

Answer

=

Question 15

Given the code:

public class Test {
    public static void change(int[] arr) {
        arr = new int[]{10, 20};
    }
    public static void main(String[] args) {
        int[] arr = {1, 2};
        change(arr);
        System.out.println(arr[0]);
    }
}

What is the output?

Accepted Answer

1. In Java, array references are passed by value. Inside the `change` method, the local variable `arr` is reassigned to a new array, but this does not affect the original array reference in `main`. Therefore, `arr[0]` in `main` still refers to the original array element `1`.

Answer

10

Answer

20

Answer

Compilation error