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

Question 1

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 2

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

Question 3

Refer to the exhibit. What is the result?

Accepted Answer

Prints 10. The code accesses the private field `x` of the `Outer` class from within the `Inner` class, which is a member inner class. In Java, a non-static inner class has access to all members (including private fields) of its enclosing outer class. The `Inner` class's `printX()` method directly accesses `Outer.this.x`, which is initialized to 10 in the `Outer` constructor, so it prints 10.

Answer

Runtime exception because Inner class is not static.

Answer

Compilation error because x is private.

Answer

Prints 0 because x is not initialized in Inner.

Question 4

A financial application uses a `Transaction` class that must be safely shared across multiple threads. The class has a mutable field `amount` and a mutable `Date` field `timestamp`. The development team needs to ensure that instances of `Transaction` can be used as keys in a `HashMap` without losing data integrity. Which two actions must be performed when overriding `equals()` and `hashCode()` in the `Transaction` class? (Choose two.)

Accepted Answer

Include both the `amount` and `timestamp` fields in the `equals()` and `hashCode()` computations.. The equals/hashCode contract requires that equal objects have equal hash codes, and that equality considers all significant fields. For the `Transaction` class, both `amount` and `timestamp` are significant, so they must be included in both methods. Failing to do so would break the contract, causing unpredictable behavior in hash-based collections. The other options are either optional best practices or incorrect approaches.

Answer

Make the `amount` and `timestamp` fields `final` to ensure immutability, which is required for using objects as keys in a `HashMap`.

Answer

Use `Objects.equals()` and `Objects.hash()` to simplify the implementation and avoid null pointer exceptions.

Answer

Override `equals()` to accept any object type by using `instanceof` without checking the class, and cast to `Transaction`.

Question 5

A developer is implementing a generic repository interface Repository with a method T findById(String id). Two implementations are created: UserRepository implements Repository and OrderRepository implements Repository. Which two statements about the use of generics in this scenario are correct? (Choose two.)

Accepted Answer

The compiler generates a bridge method in UserRepository to ensure that the method can be called through a Repository<User> reference.. Implementing a generic interface with a concrete type argument results in the method signature using that concrete type. The compiler inserts bridge methods to handle erasure and preserve polymorphism. Raw types are not needed and would bypass type safety. Type parameters are not available at runtime, so reflection cannot directly retrieve them.

Answer

Because of type erasure, both UserRepository and OrderRepository cannot coexist in the same class if they have methods with the same erasure.

Answer

The implementations must use the raw type Repository to avoid type erasure issues.

Answer

The type parameter T in Repository<T> is reified at runtime, so UserRepository can use reflection to determine that T is User.

Question 6

A class hierarchy uses a sealed interface `Vehicle` that permits `Car` and `Truck`. `Car` is declared `non-sealed` and has a subclass `ElectricCar`. A method receives a `Vehicle v` and uses a switch expression with pattern matching. Which statement about the switch is correct?

Accepted Answer

The switch is exhaustive only if it includes a default clause or a case that matches all remaining types, because `Car` being non-sealed introduces unknown subtypes.. When a sealed hierarchy includes a non-sealed subtype, the compiler loses the ability to enumerate all possible runtime types. A switch expression over the sealed interface therefore cannot be proven exhaustive by listing only the permitted direct subtypes. A default clause or another catch-all pattern is necessary. This behavior reflects the open nature of non-sealed classes, which may be extended anywhere.

Answer

The switch is exhaustive if it has cases for `Car` and `Truck`, because the sealed interface limits permitted subtypes to those two.

Answer

The switch cannot use pattern matching on a sealed interface; it must use traditional constant labels.

Answer

The switch must include a case for `Car` and a case for `Truck`; since `Car` is non-sealed, a default clause is required to handle its subclasses unless a case for `Car` is present.

Question 7

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 core purpose of the sealed class feature introduced in Java 17 is to restrict which other classes or interfaces may extend or implement it, using the permits clause to name the allowed direct subtypes. Option C is correct because any permitted subclass of a sealed class (or subinterface of a sealed interface) must itself be declared as final, sealed, or non-sealed, ensuring the hierarchy remains controlled and exhaustively known. Option B is wrong because a sealed interface can absolutely use a permits clause to specify its permitted implementing classes or extending interfaces. Option D is wrong because the permits clause lists only the permitted direct subclasses, and it may be omitted entirely when the subclasses are declared in the same source file. Option E is wrong because a sealed class need not be abstract; it can be concrete, and sealing is independent of abstractness.

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 8

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 9

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 10

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 11

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 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.. Option C is correct because since Java 8, interfaces may declare static methods that have a full implementation body; these methods belong to the interface itself and must be invoked via the interface name (e.g., InterfaceName.method()), not through an implementing instance. Option D is correct because since Java 9, interfaces may contain private methods (both private instance methods and private static methods) with bodies, which serve as helper methods for default and static methods and are not inherited by implementing classes. Option A is wrong because an interface can extend multiple interfaces using a comma-separated list (e.g., interface A extends B, C), not just one. Option B is wrong because interface fields are implicitly public static final, so they cannot be declared protected (or private, or package-private). Option E is wrong because default methods are provided to add method implementations to interfaces without breaking existing implementing classes, and they can be overridden by implementing classes, so they do not prevent overriding.

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). A top-level class in Java can be declared with the public modifier (option E), which makes the class accessible from any other package, and it can also be declared with no access modifier at all, i.e., package-private (option B), which restricts visibility to classes within the same package. These are the only two access levels the Java Language Specification permits for a top-level class, because a top-level type is always a member of a package rather than of another class. The static modifier (option A) is not an access modifier and is only meaningful for nested classes, methods, fields, and initializers, not for top-level types. The protected modifier (option C) and the private modifier (option D) are illegal on a top-level class since they only make sense for members enclosed within another class, where an enclosing type can control their visibility.

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.. Option C is correct because an overriding method must have exactly the same name as the method it overrides in the superclass, which is the fundamental basis for the override relationship. Option D is correct because the parameter list (number, types, and order of parameters) must match exactly; otherwise the method would be an overload, not an override. Option E is correct because Java permits covariant return types, meaning the overriding method's return type may be the same as, or a subtype of, the overridden method's return type. Option A is incorrect because static methods are hidden rather than overridden, and an instance method cannot override a static method. Option B is incorrect because the access modifier must be the same or less restrictive (wider), not more restrictive; a more restrictive modifier would cause a compile-time error.

Answer

The method must be static in the superclass.

Answer

The access modifier must be the same or more restrictive.