1Z0-811 Object-Oriented Programming Practice Test 2 — 15 Questions

Question 1

A developer is writing a Java class that models a temperature sensor. The class needs a constructor that accepts an initial temperature and stores it in a private double field named 'value'. The class also needs a method that returns the current temperature. Which code fragment correctly declares the constructor and the accessor method for this class?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

public TemperatureSensor(double value) { this.value = value; }
public double getValue() { return value; }. The correct fragment pairs a properly declared constructor with a matching accessor. A constructor must have the exact class name and no return type, and it should assign the parameter to the instance field using 'this' to disambiguate. The accessor must declare the field's type as its return type so callers can retrieve the encapsulated value.

Answer

public TemperatureSensor(double value) { this.value = value; }
public void getValue() { return value; }

Answer

public void TemperatureSensor(double value) { this.value = value; }
public double getValue() { return value; }

Answer

public TemperatureSensor(double value) { value = value; }
public double getValue() { return value; }

Question 2

A developer is designing a payment system. An abstract class Payment declares an abstract method process(), and a concrete subclass CreditCardPayment implements it. The developer also wants to define a constant fee rate shared by all payment types and a default method that logs a message. Which TWO statements are true about abstract classes in this design? (Choose two.)

Accepted Answer

Payment can provide a concrete method that logs a message, which CreditCardPayment inherits.. Abstract classes can hold fields, constants, and concrete methods in addition to abstract methods. A final constant fee rate and a concrete logging method are both valid members that subclasses inherit. Abstract classes cannot be instantiated, and CreditCardPayment is concrete because it implements process(). A class need not contain abstract methods to be declared abstract.

Answer

Payment must declare at least one abstract method to be considered abstract.

Answer

Payment can be instantiated directly as long as its abstract method is called later.

Answer

CreditCardPayment must be declared abstract if it does not implement process().

Question 3

A team is designing a Java class hierarchy for a graphics application. They want a superclass `Shape` that declares a method `double area()` which every subclass must provide, but `Shape` itself should not supply any implementation for `area()` because each shape calculates area differently. Which declaration in `Shape` best meets this requirement?

Accepted Answer

public abstract double area();. The requirement is a contract with no implementation, which is precisely what an abstract method expresses. Declaring area() abstract forces every concrete subclass to override it, and the compiler rejects any concrete subclass that omits the method. A default concrete body, a final method, or a private method all fail to enforce per-subclass implementation, so only the abstract declaration satisfies the design.

Answer

public final double area();

Answer

public double area() { return 0; }

Answer

private double area();

Question 4

A developer writes a class 'Vehicle' with a method 'move()' that prints 'Vehicle moves'. A subclass 'Car' overrides 'move()' to print 'Car moves'. Given: Vehicle v = new Car(); v.move(); What is the output?

Accepted Answer

Car moves. Java uses dynamic method dispatch (runtime polymorphism). Even though the reference variable is of type 'Vehicle', the actual object is a 'Car' instance. At runtime, the JVM calls the overridden 'move()' method of the 'Car' class, printing 'Car moves'.

Answer

Vehicle moves

Answer

Runtime exception

Answer

Compilation fails

Question 5

In a banking application, a class 'Account' has a private field 'balance'. Which is the best way to allow subclasses to read but not directly modify 'balance'?

Accepted Answer

Provide a public getBalance() method. It follows encapsulation: a public getBalance() method provides read-only access to the private balance field. Subclasses cannot directly modify balance because it is private. Option D (protected) is incorrect because protected access allows subclasses to directly read and write the field, which violates the requirement that subclasses should not be able to directly modify balance.

Answer

Make balance public

Answer

Use a static variable

Answer

Make balance protected

Question 6

A class 'Base' has a method 'public void display() throws IOException'. Subclass 'Derived' overrides display(). Which exception specifications are allowed in the overriding method?

Accepted Answer

public void display() throws FileNotFoundException. In Java, an overriding method can throw the same exception, a subclass of the exception thrown by the parent method, or no exception at all. The parent method throws IOException, so the overriding method may throw FileNotFoundException (a subclass of IOException). This follows the rule that the overriding method cannot throw a broader checked exception than the overridden method.

Answer

public void display() throws SQLException

Answer

public void display() throws Exception

Answer

public void display() throws Throwable

Question 7

Which design principle is violated by making all fields public in a class?

Accepted Answer

Encapsulation. Making all fields public violates the principle of encapsulation, which requires that an object's internal state be hidden from external access and only modifiable through controlled methods (getters/setters). In Java, public fields allow any class to directly read or modify the field, breaking data integrity and the ability to enforce invariants. Encapsulation is a core OOP concept that protects the internal representation of an object.

Answer

Inheritance

Answer

Abstraction

Answer

Polymorphism

Question 8

Which is the correct way to call a superclass constructor from a subclass constructor?

Accepted Answer

super(); as first statement. In Java, a call to the superclass constructor using `super()` must be the first statement in a subclass constructor. This ensures that the superclass initialization completes before any subclass-specific code executes, maintaining the inheritance chain. Option B correctly identifies this requirement.

Answer

super(); anywhere

Answer

super(); at the end

Answer

this.super();

Question 9

A developer wants to prevent a method from being overridden. Which modifier should be used?

Accepted Answer

final. The `final` modifier prevents a method from being overridden in a subclass. When a method is declared as `final`, any attempt to override it in a subclass results in a compile-time error, ensuring the method's implementation remains unchanged.

Answer

private

Answer

abstract

Answer

static

Question 10

Which TWO statements are true about interfaces in Java?

Accepted Answer

Interfaces can contain private methods.. Option A is correct because since Java 9, interfaces may declare private methods (both private instance methods and private static methods), which are used as helper methods for default and static methods within the interface and are not inherited by implementing classes. Option D is correct because every field declared in an interface is implicitly public, static, and final, meaning interface variables are constants that must be initialized and cannot be reassigned. Option B is wrong because interfaces are abstract types and cannot be instantiated with new; you must instantiate a concrete implementing class (or an anonymous class). Option C is wrong because interfaces have no constructors, since they cannot be instantiated and hold no instance state. Option E is wrong because interfaces can have default methods (introduced in Java 8), declared with the default keyword to provide a method body.

Answer

Interfaces can be instantiated.

Answer

Interfaces can contain constructors.

Answer

Interfaces cannot have default methods.

Question 11

Which THREE are benefits of using inheritance?

Accepted Answer

Code reuse. Option A (Code reuse) is correct because a subclass automatically inherits the fields and methods of its superclass, so shared behavior is written once in the parent and reused by all derived classes instead of being duplicated. Option C (Enables polymorphism) is correct because inheritance allows a subclass to override superclass methods, so a superclass reference can invoke the subclass's implementation at runtime (dynamic method dispatch), which is the foundation of polymorphism. Option D (Establishes an is-a relationship) is correct because inheritance models a taxonomic "is-a" relationship, e.g., a Car is-a Vehicle, which is the semantic basis for extending a class. Option B (Improved security) is not a benefit of inheritance itself; encapsulation and access modifiers (private, protected) govern security, and inheritance can actually weaken encapsulation. Option E (Reduces memory usage) is not a benefit of inheritance; each object instance still allocates its own instance fields, and inheritance does not inherently reduce memory footprint.

Answer

Improved security

Answer

Reduces memory usage

Question 12

A development team is building a library management system. The system has classes 'LibraryItem', 'Book', and 'DVD'. LibraryItem has a method 'getTitle()' that returns the title. Book and DVD extend LibraryItem. The team wants to ensure that when a LibraryItem is borrowed, a message specific to its type is displayed. They have a 'Borrower' class with a method 'borrow(LibraryItem item)', which currently calls 'item.getTitle()' and prints the title. Now they need to display 'Book borrowed' or 'DVD borrowed' based on the actual item type. They want to avoid using 'instanceof' checks in the 'borrow' method to keep it open for new item types. Which design should they use?

Accepted Answer

Define an abstract method 'getBorrowMessage()' in LibraryItem, and implement it in Book and DVD. Call that method in borrow().. It applies the Open/Closed Principle: LibraryItem defines an abstract getBorrowMessage() method, and each subclass provides its own implementation. The borrow() method calls this polymorphic method without needing instanceof or type checks, so adding new item types (e.g., Magazine) only requires implementing getBorrowMessage() in the new subclass without modifying existing code.

Answer

Add a String field 'type' to LibraryItem and set it in each subclass constructor. In borrow(), check the field.

Answer

Use a switch statement on the class name in borrow().

Answer

Override the 'borrow' method in each subclass and call a different method.

Question 13

Arrange the steps to implement an interface in a Java class in the correct order.

Accepted Answer

Define the interface, then create a class that implements it, then implement all abstract methods, then add extra methods, then use the class. First define the interface, then create a class that implements it, implement all abstract methods, add extra methods, and then use the class.

Answer

Create a class that implements the interface, then define the interface, then implement all abstract methods, then add extra methods, then use the class

Answer

Implement all abstract methods, then define the interface, then create a class that implements it, then add extra methods, then use the class

Answer

Use the class, then define the interface, then create a class that implements it, then implement all abstract methods, then add extra methods

Question 14

Match each Java exception class to its category.

Accepted Answer

IOException: Checked Exception. Checked exceptions (e.g., IOException, ClassNotFoundException) must be handled or declared; unchecked exceptions (e.g., NullPointerException, ArithmeticException) are RuntimeExceptions and do not require explicit handling.

Answer

NullPointerException: Checked Exception

Answer

IOException: Unchecked Exception

Question 15

A company is developing a configuration manager that must be shared across all components to ensure consistent settings. The manager should prevent direct instantiation and provide a single access point. Which design pattern and implementation should be used?

Accepted Answer

Singleton pattern with a private constructor and a static getInstance() method. The Singleton pattern ensures a class has only one instance and provides a global point of access. A private constructor prevents direct instantiation, and a static getInstance() method provides controlled access.

Answer

Prototype pattern with cloning

Answer

Builder pattern with a static inner class

Answer

Factory pattern with a public constructor