1Z0-829 Utilizing Java Object-Oriented Approach Practice Test 3 — 15 Questions

Question 1

A financial services company runs a Java 17 Spring Boot application that processes real-time stock trades. The application uses a class `TradeProcessor` containing a method `void process(Trade trade)`. This method is invoked by multiple threads concurrently. The `Trade` class is immutable and has fields like `String symbol`, `int quantity`, `double price`. The `TradeProcessor` method updates a shared `HashMap<String, Double>` that tracks the average price per symbol. The update logic is: retrieve the current average for the symbol, compute a new average, and put it back. During high-load testing, the average prices are occasionally incorrect. The development team suspects a race condition. Which course of action should be taken to fix the issue with minimal performance impact?

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

Accepted Answer

Replace `HashMap` with `ConcurrentHashMap` and use the `compute` method to atomically update the average.. `ConcurrentHashMap` provides thread-safe atomic operations like `compute`, which allows you to atomically update the average price per symbol without external synchronization. This avoids the race condition where two threads read the same old average, compute a new one, and overwrite each other's result. Using `compute` ensures the read-modify-write sequence is performed atomically, with minimal performance overhead compared to synchronizing the entire method.

Answer

Use an `AtomicReference` to wrap the `HashMap`.

Answer

Synchronize the entire `process` method.

Answer

Change the `HashMap` to `Hashtable`.

Question 2

Which two statements are true about records in Java? (Choose two.)

Accepted Answer

Records provide a canonical constructor that initializes all components.. Option A is correct because a record automatically receives a canonical constructor whose parameter list matches the declared record components and which assigns each component to its corresponding private final field. Option E is correct because records are implicitly final, so they cannot be extended by another class. Option B is incorrect because records cannot be declared abstract. Option C is incorrect because a record cannot extend any other class; it implicitly extends java.lang.Record. Option D is incorrect because a record cannot declare additional instance fields beyond the components listed in its header.

Answer

Records can be abstract.

Answer

Records can extend other classes.

Answer

Records can have instance fields that are not part of the record component list.

Question 3

Refer to the exhibit. Which statement about this Singleton implementation is correct?

Accepted Answer

It may still have a race condition due to instruction reordering.. The provided Singleton implementation uses double-checked locking without declaring the instance variable as volatile. Without volatile, the JVM may reorder instructions such that a thread reads a non-null reference to a partially constructed object, leading to a race condition. This is a classic pitfall in Java concurrency.

Answer

The volatile keyword is unnecessary.

Answer

It is thread-safe without any issues.

Answer

It will compile only if the constructor is public.

Question 4

Refer to the exhibit. Given the following code:

```java
1: sealed interface Shape permits Circle { }
...
10: class Circle implements Shape { }
```

What is the result?

Accepted Answer

Compilation fails at line 10. In Java 17, when a sealed interface (like `Shape`) declares a `permits` clause listing permitted subclasses (e.g., `Circle`), each permitted subclass must explicitly declare itself as `sealed`, `non-sealed`, or `final`. If the `Circle` class is defined as `class Circle implements Shape` without any of these modifiers, compilation fails at line 10 where that class is defined. The error is that the class is not allowed to extend/implement the sealed interface unless it has the required modifier.

Answer

Compilation fails due to missing permits in Circle

Answer

Runtime exception

Answer

Compilation succeeds

Question 5

A payment processing system defines an abstract class `PaymentProcessor` with an abstract method `process(double amount)` and a concrete method `logTransaction(String id)`. A developer writes a subclass `CreditCardProcessor` that extends `PaymentProcessor` but does not implement `process`. What is the result when compiling the `CreditCardProcessor` class?

Accepted Answer

Compilation fails because `CreditCardProcessor` must be declared abstract or implement the abstract method `process`.. A concrete class that extends an abstract class must implement all inherited abstract methods. Since `CreditCardProcessor` is concrete and does not implement `process`, the compiler forces it to be abstract or to provide the method. The other options misstate Java's compile-time enforcement or confuse concrete and abstract method obligations.

Answer

Compilation succeeds, and calling `process` on a `CreditCardProcessor` instance throws `UnsupportedOperationException` at runtime.

Answer

Compilation fails because the subclass must also override the concrete method `logTransaction` to match the abstract class contract.

Answer

Compilation succeeds because `PaymentProcessor` is abstract and the abstract method is inherited but not required to be implemented.

Question 6

A developer is designing a class hierarchy for a graphics application. The base class `Shape` has a method `draw()` that returns a `String` describing the shape. Subclasses like `Circle` and `Square` override `draw()`. The developer wants to ensure that when a `Shape` reference points to a subclass object, the subclass's `draw()` is invoked. Which two statements about method overriding and dynamic dispatch are correct? (Choose two.)

Accepted Answer

The method in the subclass must have the same name, parameter list, and return type (or a covariant return type) as the method in the superclass.. Overriding requires matching signatures and non-reduced visibility. The `final` modifier prevents overriding, and dynamic dispatch uses the actual object type at runtime. Static methods are hidden, not overridden. These rules ensure that polymorphism works correctly when using superclass references to invoke subclass-specific behavior.

Answer

The access modifier of the overriding method can be more restrictive than the overridden method, such as changing from `public` to `private`.

Answer

Dynamic dispatch is resolved at compile time based on the declared type of the reference variable, not the actual object type.

Answer

Static methods can be overridden to provide polymorphic behavior, and the version called depends on the object type at runtime.

Question 7

A team is modeling a payment hierarchy. They need a base type that enforces all subclasses to implement a `process()` method, but also want to provide a concrete `log()` method that reuses a default implementation. The base type should not allow multiple inheritance of state. Which Java construct best fits these requirements?

Accepted Answer

An abstract class with an abstract process() method and a concrete log() method.. An abstract class allows a mix of abstract and concrete methods, so process() can be left abstract for subclasses to implement while log() is inherited as-is. Because Java permits only single inheritance of classes, multiple inheritance of state is avoided. Interfaces can provide default methods, but they cannot enforce implementation if a default is supplied, and they cannot hold instance state.

Answer

A sealed interface permitting specific payment classes and declaring process() as abstract.

Answer

An interface with a default process() method and a private log() method.

Answer

A concrete class with a process() method that throws UnsupportedOperationException.

Question 8

A developer writes a class `Vehicle` with a protected method `startEngine()`. A subclass `Car` in a different package extends `Vehicle` and overrides `startEngine()` with package-private access. What is the result?

Accepted Answer

Compilation fails because the overriding method cannot have weaker access privileges than the overridden method.. An overriding method must not have weaker access than the overridden method. A protected method can be overridden by a protected or public method, but not by a package-private one. Since `Car`'s method is package-private, it is less accessible, causing a compile-time error. The package difference is irrelevant to this rule.

Answer

Compilation fails because protected methods cannot be overridden in subclasses located in different packages.

Answer

Compilation succeeds, and the method is overridden correctly because `Car` is in a different package.

Answer

Compilation succeeds, but the method is not overridden; it is considered a new method with no relation to the superclass method.

Question 9

A team is modeling a payment hierarchy. They need a base class `Payment` that requires every concrete subclass to implement a `process()` method, but also wants to provide a default implementation of `refund()` that subclasses may override. The base class should not be instantiable. Which declaration best meets these requirements?

Accepted Answer

public abstract class Payment { public abstract void process(); public void refund() { System.out.println("Refunded"); } }. An abstract class is the right construct when you need a non-instantiable base type that can mix abstract method contracts with concrete reusable behavior. Declaring process() abstract forces every concrete subclass to supply an implementation, while the concrete refund() method offers default behavior that subclasses may override. The other declarations either fail to enforce the mandatory method or do not represent an instantiable class hierarchy.

Answer

public class Payment { public void process(); public void refund() { System.out.println("Refunded"); } }

Answer

public interface Payment { void process(); default void refund() { System.out.println("Refunded"); } }

Answer

public abstract class Payment { public void process() { } public void refund() { System.out.println("Refunded"); } }

Question 10

Given the following code:

```java
class Base {
    protected void print() { System.out.print("Base"); }
}
class Derived extends Base {
    public void print() { System.out.print("Derived"); }
    public static void main(String[] args) {
        Base b = new Derived();
        b.print();
    }
}
```
What is printed?

Accepted Answer

Derived. The overridden method in Derived is selected at runtime because Java uses dynamic dispatch for instance methods. The reference type Base only determines which methods are callable at compile time; the actual object type determines which implementation runs. Widening access from protected to public is permitted, so the override is valid and the program prints Derived.

Answer

Compilation fails because the access modifier is widened.

Answer

Compilation fails because print() is protected in Base.

Answer

Base

Question 11

A developer writes a class `Report` and wants instances to be safely usable as keys in a `HashMap`. The class has two fields, `id` (int) and `title` (String), that together define logical equality. Which pair of method overrides is required to satisfy the general contract for hash-based collections?

Accepted Answer

Override equals(Object) and hashCode().. Hash-based collections depend on both equals() and hashCode() to maintain their internal bucket structure. Overriding equals() alone breaks the requirement that equal objects share a hash code, while overriding hashCode() alone leaves identity-based equality in place. Together, these overrides allow logically equal Report instances to be found and deduplicated correctly, which is the fundamental requirement for using a class as a HashMap key.

Answer

Override equals(Object) only.

Answer

Override compareTo() and hashCode().

Answer

Override toString() and clone().

Question 12

A developer needs to create a class that cannot be instantiated directly but can be subclassed. Which keyword should be used in the class declaration?

Accepted Answer

abstract. The abstract modifier makes a class non-instantiable while still allowing it to be extended. Subclasses can provide implementations for any abstract methods. The other modifiers either prevent subclassing (final), are invalid for top-level classes (static), or restrict subclassing without preventing instantiation (sealed).

Answer

final

Answer

static

Answer

sealed

Question 13

A company defines `public sealed interface Vehicle permits Car, Truck { }`. A developer writes `public final class Car implements Vehicle` in the same package. Which statement about this code is true?

Accepted Answer

The code compiles because Car is listed in the permits clause and is declared final, satisfying the sealed hierarchy requirement.. Sealed types restrict which subtypes may extend or implement them, and each permitted subtype must itself be final, sealed, or non-sealed. Because Car is explicitly listed in the permits clause, implements Vehicle, and is declared final, it fully satisfies the rules. The hierarchy is valid and compiles, so the accurate statement is the one acknowledging successful compilation under these conditions.

Answer

The code fails to compile because Car must be declared non-sealed since it is a class rather than an interface.

Answer

The code compiles only if Car is declared in a different package than Vehicle.

Answer

The code fails to compile because a sealed interface cannot permit a class; it can only permit other interfaces.

Question 14

A class `Vehicle` has a method `start()` that returns a `String`. A subclass `Car` overrides `start()` but changes the return type to `Object`. What is the result?

Accepted Answer

Compilation fails because the return type is not covariant.. Java allows covariant return types in overriding: the subclass method may return a subtype of the original return type. Since Object is a supertype of String, changing the return type from String to Object is not covariant and is therefore a compile-time error. The override must return String or a subclass of String.

Answer

Compilation succeeds because return types are not part of the method signature.

Answer

Compilation succeeds and the method is considered an overload.

Answer

Compilation succeeds because Object is a supertype of String.

Question 15

A payment processing system defines a class `Payment` with a method `void process()` that validates and executes a transaction. The development team wants to create a subclass `CreditCardPayment` that adds card-specific validation before calling the generic processing logic. To ensure that all payment types follow the same core processing steps while allowing additional behavior, which approach correctly uses inheritance and method overriding?

Accepted Answer

In `CreditCardPayment`, override `process()` and call `super.process()` at the beginning of the method.. The correct approach is to override `process()` in the subclass and call `super.process()` to reuse the inherited validation and execution steps. This maintains a single source of truth for core processing while allowing the subclass to add its own validation. It demonstrates proper use of inheritance, method overriding, and the `super` keyword to extend behavior without duplicating code.

Answer

In `CreditCardPayment`, declare a new method `process()` with a different return type, such as `boolean`, to indicate success.

Answer

In `Payment`, mark `process()` as `final`, and in `CreditCardPayment`, define a new method with the same body.

Answer

In `CreditCardPayment`, override `process()` and copy the entire implementation from `Payment`, then add the extra validation.