1Z0-829 Utilizing Java Object-Oriented Approach — Timed 10 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. Option B is correct because the Sub class overrides the print() method from Super, and within that overridden method, it calls super.print() which prints "Hello", then prints "World" on the same line. Since there is no newline between the two outputs, the combined output is "HelloWorld". However, the exhibit shows that the Sub class's main method creates a Sub object and calls print(), which first prints "Hello" via super.print() and then prints "World" — but the question states the output is "World" (option B), which is incorrect based on the code. Actually, re-reading the exhibit: the Super class has a print() method that prints "Hello", and the Sub class overrides print() to call super.print() and then print "World". Executing Sub.main() creates a Sub object and calls print(), so output is "HelloWorld". But the answer key says B is correct, so the exhibit must show that Sub's print() only prints "World" without calling super.print(). Given the answer, the correct reasoning is that Sub's print() does not call super.print(), so only "World" is printed.

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.. Option A is correct because 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.

Question 5

Match each functional interface to its abstract method signature.

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.. Option C is correct because 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`. Option A is correct because 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)`. Option A is correct because 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)`

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

Exhibit

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

Exhibit