1Z0-829 Utilizing Java Object-Oriented Approach — Timed 20 Questions

Question 1

Refer to the exhibit. Two Java classes are defined as shown. What is the output when the Sub class is executed?

Accepted Answer

World. The Sub class overrides the print() method from Super and does not call super.print(). Therefore, when Sub's print() is executed, it only prints "World" without printing "Hello". The output is simply "World".

Answer

HelloWorld

Answer

Hello

Answer

No output (compilation error)

Question 2

Which TWO statements are true about the sealed class feature in Java 17?

Accepted Answer

A sealed class restricts which other classes or interfaces may extend or implement it.. The primary purpose of the sealed class feature is to explicitly control which other classes or interfaces are permitted to extend or implement it. This is achieved by using the `permits` clause to list the allowed subclasses, thereby restricting the inheritance hierarchy.

Answer

A sealed interface cannot use the permits clause.

Answer

The permits clause must list all direct subclasses of a sealed class.

Answer

A sealed class must be declared as abstract.

Question 3

You are designing a logging framework for a microservices application. The framework must support multiple output destinations (console, file, database) and allow new destinations to be added without modifying existing code. Additionally, each destination should be able to format the log message differently. The team prefers composition over inheritance. Which design pattern should you recommend?

Accepted Answer

Observer pattern where the logger is the subject and each output destination is an observer. Formatting can be handled by each observer using a separate strategy.. The Observer pattern is correct because it decouples the logger (subject) from multiple output destinations (observers), allowing new destinations to be added without modifying existing code. Each observer can independently apply its own formatting logic, which aligns with the composition-over-inheritance principle and the requirement for per-destination formatting. This pattern directly supports the dynamic addition of observers at runtime, fulfilling the extensibility goal.

Answer

Template Method pattern where the logger defines the skeleton of logging, and subclasses override formatting and output steps.

Answer

Decorator pattern to wrap log messages with formatting, and add destinations by nesting decorators.

Answer

Factory Method pattern to create log messages, and each destination implements a different factory.

Question 4

Arrange the steps to override equals() and hashCode() correctly in Java.

Accepted Answer

Override equals() with @Override, check identity (==), check null/class, cast, compare fields, override hashCode() with @Override, use Objects.hash() with same fields. equals() and hashCode() must be consistent: if two objects are equal, they must have the same hash code. Use Objects.hash() for hashCode().

Answer

Override hashCode() with @Override and Objects.hash(), then override equals() with @Override, check identity, cast, compare fields (skip type/null check)

Answer

Override equals() with @Override, check identity, cast directly compare fields, override hashCode() with @Override using random values

Answer

Override equals() with @Override, check identity, check type, override hashCode() with @Override and Objects.hash(), then cast and compare fields

Question 5

Match each functional interface to its abstract method signature.

Accepted Answer

Predicate: boolean test(T). The correct matches are Predicate -> boolean test(T), Consumer -> void accept(T), Supplier -> T get(). Common confusions involve swapping method signatures between interfaces.

Answer

Predicate: T get()

Answer

Consumer: boolean test(T)

Answer

Function: void accept(T)

Question 6

A developer writes a class `Employee` with a private field `salary`. Which approach correctly allows subclasses to access `salary` directly without breaking encapsulation?

Accepted Answer

Change `salary` to protected.. The `protected` access modifier allows direct access to the `salary` field by subclasses (via inheritance) while still preventing access from unrelated classes outside the package. This strikes the balance between encapsulation (restricting access to the class hierarchy) and the requirement for subclass direct access.

Answer

Use package-private access (no modifier).

Answer

Make `salary` public.

Answer

Keep `salary` private and add a public getter method.

Question 7

Given the following code snippet: `List list = new ArrayList<>(); list.add(10); list.add(20); list.remove(1); System.out.println(list);` What is the output?

Accepted Answer

[10]. The code creates an ArrayList, adds 10 at index 0 and 20 at index 1. Then `list.remove(1)` removes the element at index 1, which is 20. The list now contains only [10]. Option D is correct because `remove(int index)` removes the element at the specified position, not the value.

Answer

[10, 20]

Answer

[]

Answer

[20]

Question 8

A class `Transaction` is declared as `sealed`. Which statement correctly implements a permitted subclass?

Accepted Answer

`public non-sealed class Refund extends Transaction`. A sealed class requires its permitted subclasses to be explicitly declared with `sealed`, `non-sealed`, or `final`. The `non-sealed` modifier allows the subclass to be extended further, which is valid for a permitted subclass of a sealed class.

Answer

`public sealed class Refund extends Transaction permits CashRefund`

Answer

`public final class Refund extends Transaction`

Answer

`public class Refund extends Transaction`

Question 9

Which design pattern is best suited for creating a family of related objects without specifying their concrete classes?

Accepted Answer

Abstract Factory. The Abstract Factory pattern is designed to create families of related or dependent objects without specifying their concrete classes. It provides an interface for creating families of products, ensuring that the products from one family are used together, which is a core requirement of the question.

Answer

Builder

Answer

Singleton

Answer

Factory Method

Question 10

A class `Account` has a method `public void deposit(double amount)`. Which approach correctly demonstrates method overloading?

Accepted Answer

Adding a method `public void deposit(int amount)`. Method overloading requires methods to have the same name but different parameter lists. Changing the parameter type from `double` to `int` satisfies this requirement, allowing the compiler to distinguish the methods at compile time based on the argument type.

Answer

Adding a method `public void deposit(double amount)` with different implementation

Answer

Adding a method `public int deposit(double amount)`

Answer

Adding a method `protected void deposit(double amount)`

Question 11

Given a record `Point(int x, int y)`, which statement is true about the automatically generated constructor?

Accepted Answer

You can define a compact constructor that modifies the parameters before assignment.. In Java records, you can define a compact constructor that omits the parameter list and allows you to modify the implicit parameters before they are assigned to the components. This is the only customization allowed for the canonical constructor; the compact constructor implicitly assigns the (possibly modified) parameters to the components at the end of its body.

Answer

You can define a no-arg constructor by default.

Answer

The generated constructor is package-private.

Answer

The generated constructor throws `NullPointerException` for any null component.

Question 12

A developer needs to ensure that a class `Shape` cannot be instantiated but can be extended. Which modifier should be used?

Accepted Answer

abstract. The `abstract` modifier is correct because an abstract class cannot be instantiated directly, but it can be extended by subclasses. This enforces the design intent that `Shape` serves as a base class for specific shapes like `Circle` or `Rectangle`, while preventing the creation of a generic `Shape` object.

Answer

private

Answer

final

Answer

sealed

Question 13

Which TWO statements about Java interfaces are true? (Choose two.)

Accepted Answer

Interfaces can contain static methods with a body.. Since Java 8, interfaces can contain static methods with a body. These static methods belong to the interface itself and are not inherited by implementing classes, allowing utility methods to be defined directly within the interface.

Answer

An interface can extend at most one other interface.

Answer

Fields in an interface can be declared as protected.

Answer

Default methods are used to prevent method overriding.

Question 14

Which TWO access modifiers can be applied to a top-level class in Java? (Choose two.)

Accepted Answer

package-private (no modifier). In Java, a top-level class can only have two access modifiers: public or package-private (no modifier). Package-private is the default access level when no modifier is specified, allowing the class to be accessible only within its own package. This is defined by the Java Language Specification (JLS §8.1.1).

Answer

static

Answer

protected

Answer

private

Question 15

Which THREE conditions must be true for a method to override another method in a subclass? (Choose three.)

Accepted Answer

The method name must be the same.. Method overriding requires the subclass method to have exactly the same name as the superclass method. This is a fundamental rule of polymorphism in Java, ensuring that the JVM can correctly resolve the overridden method at runtime based on the method signature.

Answer

The method must be static in the superclass.

Answer

The access modifier must be the same or more restrictive.

Question 16

What is a key difference between a class and an interface in Java?

Accepted Answer

A class can contain instance variables, while an interface cannot.. Classes can have instance variables (state), while interfaces cannot (they only declare method signatures and constants). This is a fundamental Java OOP concept.

Answer

A class cannot be used in inheritance.

Answer

An interface is automatically updated when the implementing class changes.

Answer

An interface can be instantiated directly.

Question 17

Given the exhibit, which statement about calling this method is true?

Accepted Answer

It can be called as `ClassName.getEmpName(101)`.. A static method can be called directly on the class without creating an instance. The method `getEmpName` is static and returns a value, so it can be invoked as `ClassName.getEmpName(101)`. Instance methods require an object reference, and non-static methods cannot be called in a static context without an instance.

Answer

It must be called using the `new` keyword.

Answer

It can only be called from a static context, not from an instance.

Answer

It cannot be used because it contains a loop.

Question 18

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?

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 19

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

Accepted Answer

Records provide a canonical constructor that initializes all components.. A record in Java implicitly provides a canonical constructor that accepts all the components declared in the record header and initializes them. This constructor is generated by the compiler unless a custom canonical constructor is explicitly defined, ensuring that all component fields are set upon instantiation.

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 20

Which statement about the code is correct?

Accepted Answer

A compilation error occurs in the Triangle class because Triangle is not listed in the permits clause.. In a sealed class hierarchy, the `permits` clause must list all direct subclasses. If `Triangle` extends `Shape` but is not listed in the `permits` clause of `Shape`, the compiler will report an error. The sealed class mechanism enforces that only explicitly permitted subclasses may extend the sealed class.

Answer

A compilation error occurs because Circle must be declared final.

Answer

A compilation error occurs because Shape must be declared abstract.

Answer

The code compiles successfully.