1Z0-811 Practice Test 27 — 15 Questions

Question 1

Which TWO of the following are best practices for exception handling in Java?

Accepted Answer

Catch specific exceptions rather than generic Exception or Throwable.. Catching specific exceptions (e.g., IOException, SQLException) allows you to handle each error condition appropriately, rather than using a broad catch-all like Exception or Throwable which can mask unexpected bugs and make code harder to maintain. This follows the principle of precise exception handling, ensuring that only recoverable or expected exceptions are caught, while letting runtime exceptions propagate.

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.

Question 2

A developer wants to iterate over an array of integers named 'numbers'. Which loop declaration will correctly access each element?

Accepted Answer

for (int num : numbers). It uses the enhanced for-each loop syntax, which is designed specifically for iterating over arrays and collections in Java. The colon (:) separates the element variable declaration from the array name, and each iteration assigns the next element to 'num' automatically, without needing an index or explicit bounds checking.

Answer

for (int num = 0; num < numbers.length; num++)

Answer

for (int num in numbers)

Answer

for (int num : numbers.length)

Question 3

Match each Java operator to its description.

Accepted Answer

==: Compares two values for equality. The correct matches are: == for equality, && for logical AND. Common confusions include mixing assignment (=) with comparison (==) and misunderstanding the ternary operator vs. logical operators.

Answer

!=: Used to assign a value to a variable

Answer

instanceof: Used to compare two primitive values

Answer

?:: Used to perform a logical OR operation

Question 4

Which three statements about method overloading are true? (Select three.)

Accepted Answer

Overloaded methods can have different return types.. Method overloading in Java allows methods to have different return types, provided they have different parameter lists. The return type alone is not sufficient to distinguish overloaded methods, but it can vary as long as the parameter lists differ.

Answer

Overloaded methods cannot have different access modifiers.

Answer

Overloaded methods can have the same parameter list as long as the return type differs.

Question 5

A developer runs the command shown in the exhibit. The developer wants to ensure the application uses the latest available language features. Which action should the developer take?

Accepted Answer

Download and install a newer version of the JDK.. The latest available language features (e.g., pattern matching, sealed classes, records) are tied to the JDK version. Downloading and installing a newer JDK provides both the compiler (javac) and runtime (JVM) that support those features. Simply upgrading the JVM (Option D) or using -source/-target flags (Option C) does not enable new language syntax in the compiler if the JDK itself is outdated.

Answer

Enable lambda expressions by setting the -enable-lambdas flag.

Answer

Use the -source and -target flags to compile for a newer version.

Answer

Upgrade the JVM to the latest version.

Question 6

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 7

An application requires storing a fixed set of 12 monthly temperatures. Which initialization is most appropriate?

Accepted Answer

double[] temps = {15.5, 16.2, 18.0, 20.1, 23.4, 27.8, 30.0, 29.5, 26.2, 22.0, 18.5, 16.0};. It initializes a fixed-size array of 12 doubles with the actual monthly temperature values in a single statement, which is the most appropriate for storing a fixed set of 12 values. The array size is implicitly determined by the number of elements in the initializer list, and the syntax is concise and readable for this use case.

Answer

ArrayList temps = new ArrayList<>();

Answer

double[] temps = new double[12];

Answer

double temps[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

Question 8

A package named com.example.util is declared in a file. Where should the file be placed in the directory structure?

Accepted Answer

com/example/util/. Java requires that the directory structure of a package matches the package declaration. A package named `com.example.util` must be stored in a directory hierarchy `com/example/util/` so that the Java compiler and runtime can locate the class files based on the fully qualified name. This ensures that the file is accessible via the classpath or module path.

Answer

com.example.util/

Answer

util/

Answer

com/example/util.java

Question 9

A developer writes a method that accepts an array and returns the sum of all elements. Which implementation is correct if the array might be null?

Accepted Answer

public int sum(int[] arr) { if (arr == null) return 0; int s=0; for (int n:arr) s+=n; return s; }. It explicitly checks for a null array before attempting to access its length or iterate over its elements. In Java, accessing `arr.length` or using an enhanced for loop on a null reference throws a `NullPointerException`. By returning 0 for null input, the method gracefully handles the edge case without crashing.

Answer

public int sum(int[] arr) { if (arr.length==0) return 0; int s=0; for (int n:arr) s+=n; return s; }

Answer

public int sum(int[] arr) { try { int s=0; for (int n:arr) s+=n; return s; } catch(NullPointerException e) { return -1; } }

Answer

public int sum(int[] arr) { int s=0; for (int n:arr) s+=n; return s; }

Question 10

What is the output when the main method is executed?

```java
public class Test {
    public static double add(double a, double b) {
        return a + b;
    }
    public static void main(String[] args) {
        System.out.println(add(5, 10));
    }
}
```

Accepted Answer

15.0. The code defines a single method `public static double add(double a, double b) { return a + b; }`. The main method calls `System.out.println(add(5,10));`. Java performs implicit widening conversion of the integer literals 5 and 10 to double, resulting in 15.0. Options 5.0 and 10.0 would be incorrect because the method adds the arguments. Option D is incorrect because there is no ambiguity — only one method matches after widening.

Answer

5.0

Answer

10.0

Answer

Compilation error: ambiguous method call

Question 11

Given the following code:

class A {
    A() { System.out.print("A "); }
}
class B extends A {
    B() { System.out.print("B "); }
}
class C extends B {
    C() { System.out.print("C"); }
    public static void main(String[] args) {
        new C();
    }
}

What is the output when running the main method?

Accepted Answer

A B C. In Java, when an object of a subclass is created, constructors are executed from the topmost superclass down to the subclass. Assuming the exhibit shows class C extends B extends A, with each constructor printing its class name, the output will be A B C.

Answer

B A C

Answer

A C B

Answer

C B A

Question 12

Given: boolean a = false; boolean b = true; boolean c = true; System.out.println(a || b && c); What is the output?

Accepted Answer

true. In Java, the logical AND operator (&&) has higher precedence than the logical OR operator (||). Therefore, the expression `a || b && c` is evaluated as `a || (b && c)`. Given `a = false`, `b = true`, and `c = true`, `b && c` evaluates to `true`, and then `false || true` evaluates to `true`. Thus, the output is `true`, making option D correct.

Answer

false

Answer

Compilation fails

Answer

None of the above

Question 13

A developer is implementing a login system where users enter a password that is then hashed using SHA-256. The system stores the hash as a String in the database. On login, the entered password is hashed and compared to the stored hash using the == operator. Occasionally, valid users are denied access, even though the hashes are identical when printed. The developer has confirmed that the hash algorithm is correctly implemented and that the stored hash is exactly the same string as the computed hash. What is the most likely cause and correct fix?

Accepted Answer

Change the comparison from == to equals().. The == operator in Java compares object references, not string content. Even if two hash strings are logically identical, they are distinct String objects, so == returns false. Option A (equals()) is the correct and idiomatic fix because equals() compares the actual content. Option B (hashCode()) is incorrect because hash codes can collide (different strings can have the same hash code), and passwords require exact string equality. Option C (intern()) would allow == to work after interning, but it is unnecessary and not recommended for password validation due to the permanent string pool and performance overhead. Option D (compareTo()) would also return 0 for equal strings, but equals() is the standard method for equality checks.

Answer

Use hashCode() to compare integer representations.

Answer

Call intern() on both hash strings before using ==.

Answer

Use compareTo() which returns 0 if equal.

Question 14

Refer to the exhibit. What is the result of attempting to compile and run the code?

Accepted Answer

Compilation error because x is private in A. The code fails to compile because class B attempts to access the private field `x` of class A from a different class. In Java, private members are only accessible within the same class, not from subclasses or other classes, even if they are in the same file. The `super.x` reference in class B is illegal, causing a compilation error.

Answer

Prints 0

Answer

Runtime error

Answer

Prints 5

Question 15

Which TWO statements are true about passing arrays to methods in Java?

Accepted Answer

The method can modify the elements of the array.. Java passes object references by value. When an array is passed to a method, the method receives a copy of the reference to the array object. This copy still points to the same array object in heap memory, so the method can modify the elements of the array through that reference. These modifications are visible to the caller because they affect the same underlying array object.

Answer

The method can reassign the original array variable to a new array.

Answer

The method must return the array to reflect any changes.

Answer

The method cannot determine the size of the array.