1Z0-829 Utilizing Java Object-Oriented Approach — 15 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.