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

Question 1

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 2

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 3

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 4

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 5

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.

Question 6

You are designing a logging framework for a distributed application. The framework must support multiple output destinations (console, file, network socket) and allow clients to dynamically add new destinations at runtime without modifying existing code. Currently, the application uses a single static Logger class with methods like logToConsole(String msg) and logToFile(String msg). The team needs to refactor the code to adhere to the Open/Closed Principle and support extensibility. After reviewing the requirements, you propose using a combination of an interface and a strategy pattern. However, a senior developer argues that using a simple enum with abstract methods would be sufficient. Which course of action best adheres to object-oriented design principles and allows the most flexibility for future extensions?

Accepted Answer

Refactor Logger to be an interface, and implement concrete destination classes (ConsoleLogger, FileLogger, SocketLogger). Use dependency injection to pass the desired destination to the Logger client.. Refactors Logger to be an interface and uses dependency injection, allowing clients to pass any implementation. This adheres to the Open/Closed Principle because new destinations can be added by creating new classes implementing Logger without modifying existing code. Option C (using an enum with abstract methods) violates OCP because adding a new destination requires modifying the enum. Option A (keeping static methods and adding new ones) also requires modification of the Logger class. Option D (abstract class with subclasses and factory) still requires modifying the factory when adding new destinations, reducing flexibility.

Answer

Keep the existing static methods but add a new method for each destination as needed. Use conditional logic to select the destination at runtime.

Answer

Create an enum LogDestination with values CONSOLE, FILE, SOCKET, each overriding an abstract log(String) method. The Logger class uses a static method that accepts a LogDestination and calls its log method.

Answer

Refactor Logger to be an abstract class with an abstract log method, and create subclasses for each destination. Use a factory method to instantiate the correct subclass.

Question 7

Refer to the exhibit. What is the output?

Accepted Answer

30
20
10. The code uses a Deque (ArrayDeque) and calls push() to add elements, which adds them to the front of the deque (LIFO order). The for-each loop iterates from the head (first) to the tail (last), so it prints 30, 20, 10. Option B is correct because push() behaves like a stack, and iteration follows the deque's head-to-tail order.

Answer

10
20
30

Answer

20
30
10

Answer

30
10
20

Question 8

Refer to the exhibit. What is the result?

Accepted Answer

Bark
Playing. The code compiles and runs without error. The object referenced by a1 is a Dog instance. The code first calls the bark() method, which prints 'Bark' (defined in Dog). Then it calls the play() method, which is not overridden in Dog, so it invokes the inherited play() method from Animal, printing 'Playing'. Therefore, the output is 'Bark' followed by 'Playing', which matches option B.

Answer

Compilation fails

Answer

Runtime exception

Answer

Bark

Question 9

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 10

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 11

Refer to the exhibit. What is the output?

Accepted Answer

true
true. The code uses `equals()` on two `String` objects with the same content ("Test"), which returns `true`. The second `println` uses `==` to compare the same two `String` references; since both reference the same string literal from the string pool, `==` also returns `true`. Thus both lines print `true`.

Answer

Compilation fails

Answer

true
false

Answer

false
true

Question 12

Refer to the exhibit. What is the most direct way to fix the compilation error without changing the access modifier of the field?

Accepted Answer

Change line 14 to System.out.println(emp.getName());. The compilation error is caused by attempting to access a private field `name` directly via `emp.name` from a different class. The most direct fix without changing the access modifier is to use the public getter method `getName()`, which provides controlled access to the private field. This adheres to encapsulation principles and resolves the visibility issue.

Answer

Move the main method to another class in the same package.

Answer

Import the class in the same file and create a subclass.

Answer

Change line 14 to System.out.println(emp.name); and make the field protected.

Question 13

Refer to the exhibit. What is the result of compiling and running the Main class?

Accepted Answer

Compilation error at line 8 because makeSound() has protected access.. The `makeSound()` method in the `Animal` class has `protected` access, and the `Dog` class is in a different package. In Java, a `protected` member is accessible only within the same package or through inheritance in a subclass, but only if the access is via a reference of the subclass type. In the `Main` class, the reference is of type `Animal` (line 8), not `Dog`, so the compiler cannot access the `protected` method from a different package, resulting in a compilation error.

Answer

Runtime exception because makeSound() is not accessible.

Answer

Compilation error because Dog does not override makeSound().

Answer

Prints "Some sound".

Question 14

Refer to the exhibit. What is the result of compiling and running the Test class?

Accepted Answer

Compilation error at line 9 because Vehicle does not have a drive() method.. The reference type of the variable `v` is `Vehicle`, and the `Vehicle` interface does not declare a `drive()` method. Since the compiler checks the reference type for method availability, calling `v.drive()` results in a compilation error, even though the actual object is a `Car` that has a `drive()` method.

Answer

Runtime exception because drive() is not accessible.

Answer

Prints "Car engine started" followed by "Car is moving".

Answer

Compilation error because Car does not implement all abstract methods.

Question 15

Refer to the exhibit. What is the output?

Accepted Answer

Class implementation. When a class implements an interface that provides a default method, the class can override that default method with its own implementation. In this case, the class provides a concrete implementation of the `show()` method, which takes precedence over the interface's default method. Therefore, the output is 'Class implementation'.

Answer

Runtime exception due to conflicting methods.

Answer

Compilation error because show() is default in interface and cannot be overridden.

Answer

Interface default