1Z0-811 Practice Test 13 — 15 Questions

Question 1

A developer wants to sort an array of primitive ints in descending order. Which approach will work without using third-party libraries?

Accepted Answer

Arrays.sort(arr); // then reverse the array manually. `Arrays.sort(int[])` sorts the array in ascending order, and then manually reversing the array yields descending order. The other options fail because `Arrays.parallelSort()` also sorts ascending, `Collections.reverseOrder()` requires an array of objects (not primitives), and a custom comparator cannot be used with primitive arrays in Java.

Answer

Arrays.parallelSort(arr);

Answer

Arrays.sort(arr, Collections.reverseOrder());

Answer

Arrays.sort(arr, (a,b) -> b - a);

Question 2

Which THREE are checked exceptions in Java? (Choose three.)

Accepted Answer

SQLException. B, SQLException, is a checked exception because it extends java.lang.Exception (not RuntimeException) and the compiler requires callers to catch or declare it when using JDBC operations. D, IOException, is the canonical checked exception for I/O failures and must be handled or declared via throws. E, FileNotFoundException, is a subclass of IOException and therefore also checked, requiring explicit handling when opening files. The unmarked options do not belong because A, ArrayIndexOutOfBoundsException, and C, NullPointerException, are both subclasses of RuntimeException, making them unchecked exceptions that the compiler does not force you to catch or declare.

Answer

ArrayIndexOutOfBoundsException

Answer

NullPointerException

Question 3

Refer to the exhibit. What is the output?

Accepted Answer

int. The code performs an integer division because the double y is cast to int, making both operands int. The result is an int value of 2. The method typeOf(int) is called, which prints the string 'int'.

Answer

double

Answer

Runtime error

Answer

Compilation error

Question 4

Match each access modifier to its visibility level.

Accepted Answer

private: Visible only within the same class. In Java, access modifiers control visibility: private (class-only), default (package), protected (package + subclasses), public (everywhere). Common mistakes include confusing private with default and protected with private.

Answer

private: Visible within the same package

Answer

protected: Visible only within the same class

Question 5

A method that calculates the average of an array of doubles is defined as:

public static double average(double[] values) {
    double sum = 0;
    for (double v : values) sum += v;
    return sum / values.length;
}

Which call is valid?

Accepted Answer

double avg = average(new double[]{1.0, 2.0, 3.0});. The method `average(double[] values)` expects a single argument of type `double[]`. The expression `new double[]{1.0, 2.0, 3.0}` creates an anonymous array object that matches the parameter type exactly, so the call compiles and runs correctly.

Answer

double avg = average(1.0, 2.0);

Answer

double avg = average(1.0, 2.0, 3.0);

Answer

double avg = average({1.0, 2.0, 3.0});

Question 6

A method receives an int parameter and modifies its value inside the method. Does this change affect the caller's argument?

Accepted Answer

No, because Java passes a copy of the value. Java uses pass-by-value for all parameters. When an int is passed to a method, a copy of the value is made, so modifications inside the method affect only the copy, not the original variable in the caller's scope.

Answer

No, unless the parameter is marked as volatile

Answer

Yes, because the parameter is an int

Answer

Yes, because Java passes a reference

Question 7

Given: int a = 9; int b = 2; double c = a / b; System.out.println(c); What is the output?

Accepted Answer

4.0. The expression `a / b` performs integer division because both operands are `int`. The result of `9 / 2` is `4` (the fractional part is truncated). This integer result is then implicitly widened to `double` when assigned to `c`, producing `4.0`. Therefore, the output is `4.0`.

Answer

4.5

Answer

0.0

Answer

4

Question 8

You are maintaining a multi-threaded banking application that processes transactions. In the `processTransaction` method, you have a try-catch block that catches `Exception` to handle any unexpected errors. Recently, the application intermittently fails to update account balances correctly due to unhandled exceptions. The logs show that sometimes a `RuntimeException` is thrown from a nested method, but it is not being logged or handled properly, leading to inconsistent state. The team wants to improve the exception handling to ensure that all exceptions are caught, logged, and the transaction is rolled back properly. The method currently uses a primitive try-catch-finally where the finally block commits the transaction if no exception occurred. Which approach best addresses the issue while maintaining clarity and correctness?

Accepted Answer

Inside the try block, set a boolean success flag to true upon completion; in the finally block, check the flag: if false, rollback; if true, commit. Additionally, catch specific exceptions, log them, and ensure rollback logic is invoked.. Option C is correct because it uses a boolean success flag set inside the try block; the finally block checks the flag to commit only if success, and rolls back otherwise. This ensures the transaction is committed only when no exception occurred. Additionally, catching specific exceptions (including RuntimeException) and logging them provides proper error handling. Option A is wrong because removing the catch block eliminates the ability to log and handle exceptions specifically, even though a boolean flag in finally can manage the commit/rollback. Option B is wrong because even though it adds a catch for RuntimeException and calls rollback, the finally block still unconditionally commits afterward, which can override the rollback. Option D is wrong because declaring throws Exception pushes the rollback responsibility to the caller without resolving the local transaction consistency.

Answer

Remove the `catch (Exception e)` block and rely solely on the finally block to commit or roll back based on a boolean flag set in the try block.

Answer

Add a separate catch block for `RuntimeException` before the existing `catch (Exception e)` and call rollback there, then rethrow the exception.

Answer

Declare the method with `throws Exception` and let the caller handle the transaction rollback.

Question 9

Which three of the following statements about primitive type conversion are true?

Accepted Answer

Implicit widening conversion is allowed from int to long.. Option B is correct because implicit widening conversion follows the Java primitive promotion hierarchy, where a 32-bit int safely fits into a 64-bit long without loss of information, so no cast is required. Option D is correct because char is an unsigned 16-bit type and int is a 32-bit signed type, so every possible char value (0–65535) fits within int's range, allowing assignment without an explicit cast. Option E is correct because converting double to int is a narrowing conversion that can lose the fractional part and may exceed int's range, so the compiler requires an explicit cast such as (int) to acknowledge the potential data loss. Option A is not correct because float to long is a narrowing conversion (float has a wider range and fractional precision) and requires an explicit cast, not an implicit one. Option C is not correct because boolean is not convertible to any numeric primitive type in Java, even with casting; boolean and int are incompatible types.

Answer

A float can be implicitly converted to long.

Answer

A boolean can be converted to int using casting.

Question 10

A company is developing a security-sensitive banking application. Which Java feature most directly enhances security?

Accepted Answer

Bytecode verification. Bytecode verification is the Java feature that most directly enhances security because it ensures that compiled Java bytecode adheres to the JVM's safety rules before execution, preventing malformed or malicious bytecode from compromising the runtime. The verifier checks type safety, stack integrity, and access control, blocking many low-level attacks.

Answer

Automatic garbage collection

Answer

Platform independence via bytecode

Answer

Built-in multithreading support

Question 11

Which THREE statements about the final keyword in Java are true?

Accepted Answer

A final variable cannot be reassigned after initialization.. Option A is correct because a final variable can be assigned only once, so any attempt to reassign it after initialization causes a compile-time error. Option B is correct because final applies to the reference itself, not the referenced object: the reference must keep pointing to the same object, although the object's internal state can still be mutated. Option E is correct because declaring a class final prevents any other class from extending it, which is why classes like java.lang.String are final. Option C is incorrect because a final method cannot be overridden in a subclass (it can only be inherited and used as-is). Option D is incorrect because a final parameter cannot be reassigned inside the method, so the method cannot modify the argument value.

Answer

A final method can be overridden in a subclass.

Answer

A final parameter in a method allows the method to modify the argument value.

Question 12

A stock trading system calculates daily profit using an int variable. During periods of high volatility, the profit can exceed Integer.MAX_VALUE (2,147,483,647). When this happens, the profit value wraps around to a negative number, leading to incorrect reporting. The lead developer wants to detect the overflow and throw an ArithmeticException rather than silently producing wrong results. The code cannot use long or BigInteger due to legacy constraints. Which approach should be taken?

Accepted Answer

Use Math.addExact() for the addition and catch or let the exception propagate.. Math.addExact() performs integer addition and throws an ArithmeticException if the result overflows, exactly meeting the requirement to detect overflow and throw an exception without changing data types. Option A (bitwise AND) does not detect overflow reliably. Option C (casting to long) changes the data type, violating the legacy constraint. Option D (BigInteger) also changes the data type. Therefore, option B is correct.

Answer

Use bitwise AND with a mask to detect overflow.

Answer

Cast the operands to long before addition and then cast back to int.

Answer

Use BigInteger for the calculation and convert back to int.

Question 13

Refer to the exhibit. Given the code, what is the value printed to the console?

Accepted Answer

18. 18 (option C). The expression `a++ + --b * 2` is evaluated according to Java operator precedence: postfix increment (`a++`) uses the current value of `a` (10) then increments `a` to 11; prefix decrement (`--b`) decrements `b` from 5 to 4 then uses 4; multiplication has higher precedence than addition, so `--b * 2` computes 4 * 2 = 8; then addition: 10 + 8 = 18. Option A (19) would result if the postfix increment had been applied before the rest of the expression (i.e., using 11 instead of 10). Option B (21) would result if both increments were applied before evaluation (a becomes 11, b becomes 4, and then 11 + 4 * 2 = 11 + 8 = 19, not 21; actually 21 is far off). Option D (20) would result if addition were performed before multiplication (10 + 4 = 14, then 14 * 2 = 28, not 20; 20 is not directly derivable). Thus only step-by-step evaluation yields 18.

Answer

19

Answer

21

Answer

20

Question 14

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

Accepted Answer

Overloaded methods can have different return types.. Option A is correct because the return type is not part of a method's signature, so two overloaded methods may declare different return types as long as their parameter lists differ. Option C is correct because access modifiers (public, protected, private, or default) are also not part of the signature, so overloaded methods can vary in visibility. Option E is correct because overloading is defined by methods sharing the same name but having different parameter lists (different number, types, or order of parameters). Option B is wrong because access modifiers may differ between overloaded methods. Option D is wrong because two methods with identical parameter lists are not overloads even if their return types differ; that is a compile-time error in Java.

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 15

Which THREE are benefits of using inheritance?

Accepted Answer

Code reuse. Option A (Code reuse) is correct because a subclass automatically inherits the fields and methods of its superclass, so shared behavior is written once in the parent and reused by all derived classes instead of being duplicated. Option C (Enables polymorphism) is correct because inheritance allows a subclass to override superclass methods, so a superclass reference can invoke the subclass's implementation at runtime (dynamic method dispatch), which is the foundation of polymorphism. Option D (Establishes an is-a relationship) is correct because inheritance models a taxonomic "is-a" relationship, e.g., a Car is-a Vehicle, which is the semantic basis for extending a class. Option B (Improved security) is not a benefit of inheritance itself; encapsulation and access modifiers (private, protected) govern security, and inheritance can actually weaken encapsulation. Option E (Reduces memory usage) is not a benefit of inheritance; each object instance still allocates its own instance fields, and inheritance does not inherently reduce memory footprint.

Answer

Improved security

Answer

Reduces memory usage