1Z0-811 Practice Test 25 — 15 Questions

Question 1

What is the output of the following code?

int i = 0;
while (i < 5) {
    if (i == 3) {
        i++;
        continue;
    }
    System.out.print(i + " ");
    i++;
}

Accepted Answer

0 1 2 4. The while loop iterates while i < 5. When i equals 3, the if condition triggers, incrementing i to 4 and then using continue to skip the print statement for that iteration. Thus, 3 is never printed, and the loop prints 0, 1, 2, and then 4 before i becomes 5 and the loop ends.

Answer

0 1 2 3

Answer

0 1 2 4 5

Answer

0 1 2 3 4

Question 2

In a Java application, a class 'OrderProcessor' contains a method that processes orders. The method currently handles multiple responsibilities: validating order data, calculating totals, updating inventory, and sending notifications. The team wants to refactor this method to follow the Single Responsibility Principle. Which action should they take?

Accepted Answer

Create separate classes or methods for each responsibility and compose them in OrderProcessor. It separates each responsibility into its own class or method and composes them in OrderProcessor, which adheres to the Single Responsibility Principle. Option A is wrong because a single utility method with if-else still violates SRP by handling multiple responsibilities. Option B is wrong because overriding in subclasses does not separate concerns within the same method; it shifts responsibilities but does not eliminate the violation. Option C is wrong because merging responsibilities into a superclass increases coupling and does not adhere to SRP.

Answer

Use a single utility method that uses if-else for each case

Answer

Override the method in subclasses for each responsibility

Answer

Merge all responsibilities into a superclass

Question 3

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.. In Java, a checked custom exception (one that extends Exception but not RuntimeException) is a checked exception. The Java Language Specification (JLS) requires that any method which might throw a checked exception must either handle it with a try-catch block or declare it in its throws clause. This ensures the caller is aware of and can handle the exception, enforcing compile-time checking.

Answer

A custom exception class must directly extend Throwable.

Answer

A custom exception cannot have constructors that call super.

Question 4

Refer to the exhibit. What is the output?

Accepted Answer

true. The code uses `==` to compare two `String` objects created with string literals (e.g., `String s1 = "true"; String s2 = "true";`). In Java, string literals are interned, meaning they refer to the same object in the string pool. Therefore, the reference comparison returns `true`. The `==` operator checks reference equality, not content equality, but due to interning, the references are the same. If `new String("true")` were used, the comparison would be `false` because different objects are created.

Answer

Runtime exception

Answer

Compilation error

Answer

false

Question 5

A method throws a checked exception. Which of the following is the correct way to handle it in the calling method?

Accepted Answer

Enclose the call in a try-catch block.. Checked exceptions must be handled by the calling method either by catching them with a try-catch block or by declaring them in a throws clause. Since the question asks for the correct way to handle it, enclosing the call in a try-catch block is a valid and direct handling approach that prevents the exception from propagating unhandled.

Answer

Ignore the exception since it is checked.

Answer

Add a throws clause to the calling method.

Answer

Use a finally block without catch.

Question 6

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 7

A programmer wants to iterate over a list of strings and print each that starts with 'A'. Which loop construct is best suited?

Accepted Answer

Enhanced for loop. The enhanced for loop (for-each) is best suited because it provides a clean, concise syntax for iterating over a collection like a List<String> without needing an explicit index or iterator. It directly yields each element, allowing a simple if-statement to check if the string starts with 'A' and print it, making the code more readable and less error-prone.

Answer

Do-while loop

Answer

Traditional for loop with index

Answer

While loop with iterator

Question 8

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 9

Consider: for(int i=0;i<10;i++) { int x = i; } System.out.println(x); What is the result?

Accepted Answer

Compilation error. The variable `x` is declared inside the `for` loop block, so its scope is limited to that block. Attempting to use `x` outside the loop (in the `System.out.println(x);` statement) causes a compilation error because `x` is not in scope at that point. The Java compiler enforces block-level scoping rules, and any reference to a variable outside its declared block results in a 'cannot find symbol' error.

Answer

9

Answer

10

Answer

0

Question 10

A method 'public static int[] generate() { int[] result = new int[10]; for (int i = 0; i < result.length; i++) result[i] = i * 2; return result; }' is defined. Which statement correctly calls this method and stores the result?

Accepted Answer

int[] data = generate();. The method `generate()` returns an `int[]` (an array of integers), and the assignment `int[] data = generate();` correctly declares a reference variable of type `int[]` and assigns the returned array to it. The method is static, so it can be called directly from a static context without an instance.

Answer

int[] data = new int[generate()];

Answer

int data = generate();

Answer

generate();

Question 11

Which THREE of the following are checked exceptions in Java?

Accepted Answer

java.sql.SQLException. `java.sql.SQLException` is a checked exception in Java, meaning it must be either caught or declared in the method signature using `throws`. Checked exceptions are subclasses of `Exception` but not of `RuntimeException`, and `SQLException` directly extends `java.lang.Exception`, making it a checked exception that the compiler enforces handling for.

Answer

java.lang.NullPointerException

Answer

java.lang.ArithmeticException

Question 12

Which assignment requires an explicit cast to compile?

Accepted Answer

int i = 10L;. Requires an explicit cast because it assigns a `long` literal (10L) to an `int` variable. In Java, `long` is a 64-bit type and `int` is 32-bit, so this is a narrowing primitive conversion that loses precision and must be explicitly cast with `(int)`. Without the cast, the compiler rejects it as a possible lossy conversion.

Answer

double d = 10;

Answer

long l = 10;

Answer

float f = 10.5f;

Question 13

A developer receives a ticket that a batch processing job is running indefinitely. The job reads records from a database and processes them in a loop. The code uses a while(true) loop with a break condition when a sentinel value is encountered. However, due to a data anomaly, the sentinel value is never reached, causing the loop to run forever. The developer needs to fix the loop to prevent infinite execution while still allowing processing of all records until the sentinel is reached. Which approach is most appropriate?

Accepted Answer

Add a counter variable and break after a maximum number of iterations. Adding a counter variable and breaking after a maximum number of iterations provides a safety net against infinite loops while still allowing the loop to process all records until the sentinel is reached under normal conditions. This approach is a common defensive programming technique in Java to handle unexpected data anomalies without altering the core loop logic.

Answer

Use a do-while loop that checks the condition at the end

Answer

Change the loop to a for loop with a fixed range based on the expected number of records

Answer

Throw an exception when the loop runs too long

Question 14

A financial trading application processes high-volume transactions. The system uses a multithreaded architecture where multiple threads update a shared Account object's balance field. Recently, intermittently incorrect balance calculations have been reported. Developers suspect a race condition on the balance field. The Account class is defined as follows:

public class Account {
    private double balance = 0.0;
    public void deposit(double amount) { balance += amount; }
    public void withdraw(double amount) { balance -= amount; }
    public double getBalance() { return balance; }
}

Threads are created using ExecutorService with a fixed thread pool. The issue occurs only under heavy load. Which course of action should the development team take to resolve the issue while maintaining performance?

Accepted Answer

Synchronize the deposit and withdraw methods.. Synchronizing the `deposit` and `withdraw` methods ensures mutual exclusion on the `balance` field. In Java, the compound operations `balance += amount` and `balance -= amount` are not atomic; they involve a read, modify, and write sequence. Synchronization guarantees that only one thread executes these methods at a time, preventing race conditions and ensuring correct balance calculations under heavy load.

Answer

Declare the balance field as volatile.

Answer

Use AtomicLong and convert to double.

Answer

Wrap the balance field in a synchronized block within each method using a separate lock object.

Question 15

A method is declared as: public static int[] generateSequence(int n) { ... }. Which return statement is valid inside this method?

Accepted Answer

return new int[n];. The method's return type is `int[]`, meaning it must return a reference to an integer array. Option B, `return new int[n];`, creates an array of length `n` and returns it, which is valid. Option D, `return new int[0];`, also creates an integer array (of length 0) and returns it, which is syntactically valid as well. Options A and C are invalid because they return primitive `int` values, not `int[]` references. Therefore, both B and D are correct return statements.

Answer

return result; where result is an int variable

Answer

return 0;