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

Question 1

A Java class named 'Helper' is defined in package 'utils'. Another class in a different package tries to access a public method of Helper but receives a compilation error. The Helper class is declared as 'class Helper' (without public modifier). What is the likely issue?

Accepted Answer

The class has package-private access. Option B is correct because a class with no access modifier (default) has package-private visibility, so it cannot be accessed from outside its package. Option A is wrong because the method being static is irrelevant to access. Option C is wrong because final does not affect access. Option D is wrong because abstract does not restrict access.

Answer

The method is declared as final

Answer

The method is not static

Answer

The class is abstract

Question 2

In a banking application, a class 'Account' has private field 'balance' and public methods 'getBalance()' and 'setBalance(double)'. This is an example of which OOP principle?

Accepted Answer

Encapsulation. Option D is correct because encapsulation hides internal data and provides controlled access via methods. Option A is wrong because there is no inheritance involved. Option B is wrong because polymorphism is not shown. Option C is wrong because abstraction is about hiding complexity, not data protection.

Answer

Abstraction

Answer

Inheritance

Answer

Polymorphism

Question 3

A team is designing a system where a 'Report' class can be generated in different formats (PDF, Excel, HTML). They want to avoid modifying the Report class when adding new formats. Which OOP principle or pattern should they use?

Accepted Answer

Composition. Option A is correct because composition (or Strategy pattern) allows the Report class to delegate format generation to separate objects, enabling easy extension. Option B is wrong because inheritance would create a rigid hierarchy. Option C is wrong because Singleton ensures a single instance, not flexibility. Option D is wrong because method overloading is compile-time and not suitable for adding new formats dynamically.

Answer

Method Overloading

Answer

Inheritance

Answer

Singleton

Question 4

A class 'Animal' has a method 'makeSound()'. Subclasses 'Dog' and 'Cat' override it. When calling makeSound() on an Animal reference that actually holds a Dog object, the Dog's version is executed. This is an example of:

Accepted Answer

Dynamic binding. Option A is correct because dynamic binding (runtime polymorphism) resolves method calls based on actual object type. Option B is wrong because static binding happens at compile-time. Option C is wrong because overloading is compile-time. Option D is wrong because encapsulation does not relate to method dispatch.

Answer

Static binding

Answer

Encapsulation

Answer

Method overloading

Question 5

A Java application uses an interface 'Drawable' with a default method 'draw()'. A class 'Circle' implements Drawable but does not override draw(). Another class 'Square' implements Drawable and overrides draw(). Which statement is true about calling draw() on instances of Circle and Square?

Accepted Answer

Circle will use the default, Square will use its own. Option B is correct because classes inherit default interface methods; Circle inherits the default, Square overrides it. Option A is wrong because Square uses its own version. Option C is wrong because Circle does not cause an error. Option D is wrong because both compile successfully.

Answer

Square will use the default, Circle will cause a compilation error

Answer

Both will use the default implementation

Answer

Both will cause a compilation error

Question 6

Which TWO of the following are valid benefits of using inheritance in Java? (Choose two.)

Accepted Answer

Allows polymorphic behavior. Options A and C are correct. Inheritance promotes code reuse by allowing subclasses to inherit fields and methods from superclasses. It also enables polymorphic behavior through method overriding. Option B is wrong because inheritance increases coupling, not a benefit. Option D is wrong because inheritance can complicate debugging. Option E is wrong because encapsulation is enforced by access modifiers, not inheritance.

Answer

Increases coupling between classes

Answer

Enforces encapsulation

Answer

Simplifies debugging

Question 7

Which THREE statements are true about interfaces in Java? (Choose three.)

Accepted Answer

An interface can extend multiple interfaces. Options A, B, and D are correct. Interfaces can extend multiple interfaces using the extends keyword. Since Java 8, interfaces can contain static methods (with body) and default methods. Option C is wrong because interfaces cannot be instantiated directly. Option E is wrong because interface fields are implicitly public static final; private fields are not allowed (private methods are allowed since Java 9, but not fields).

Answer

An interface can be instantiated directly

Answer

An interface can have private fields

Question 8

Which THREE are fundamental principles of Object-Oriented Programming? (Choose three.)

Accepted Answer

Encapsulation. Options A, B, and C are correct. Encapsulation, inheritance, and polymorphism are core OOP principles. Option D is wrong because compilation is a language process, not an OOP principle. Option E is wrong because modularization is a design concept, not a foundational OOP principle.

Answer

Compilation

Answer

Modularization

Question 9

Refer to the exhibit. What is the problem with this class?

Accepted Answer

The constructor parameter shadows the field, causing name to remain null. Option A is correct because the constructor parameter name shadows the field name, and the assignment 'name = name' assigns the parameter to itself, leaving the field null. Option B is wrong because the field is private and accessible within the class. Option C is wrong because constructors don't have return types. Option D is wrong because the method returns a String correctly.

Answer

The constructor is missing a return type

Answer

The getName method should be void

Answer

The field name is private and cannot be accessed within the class

Question 10

A team is developing a large-scale e-commerce platform using Java. They have a class hierarchy: Product (abstract), Electronics, Clothing, Food. Each product has a discount method that applies different logic. The team notices that whenever a new product type is added, they must modify the existing discount calculation logic in multiple places, leading to high maintenance costs. They want to refactor to follow the Open/Closed Principle. Which approach should they take?

Accepted Answer

Define an interface Discountable with a method calculateDiscount() and have each product class implement it. Option A is correct because defining an interface Discountable with a calculateDiscount() method and having each product class implement it allows adding new product types without modifying existing code. Option B is wrong because it violates OCP by requiring changes to a switch statement. Option C is wrong because it also requires modification when new types are added. Option D is wrong because it uses reflection unnecessarily and still requires changes to map types.

Answer

Create a single discount method in Product that uses if-else checks on type

Answer

Remove the discount method and handle it externally using reflection

Answer

Use a switch statement in a utility class to handle all product types

Question 11

A developer is working on a Java application that processes sensor data. The code uses a class 'SensorDataProcessor' which directly instantiates specific sensor classes like 'TemperatureSensor' and 'PressureSensor' inside its methods. The team wants to make the system extensible to support new sensor types without modifying the processor class. Which design change best achieves this?

Accepted Answer

Define a Sensor interface and use dependency injection to pass sensor objects to the processor. Option B is correct because defining a Sensor interface and using dependency injection (e.g., passing sensor objects via constructor or setter) decouples the processor from concrete sensor classes. Option A is wrong because creating subclasses for each sensor would still require modifying the processor if new sensor types are added. Option C is wrong because a static factory still couples the processor to the factory. Option D is wrong because reflection is complex and not the best practice for this scenario.

Answer

Make SensorDataProcessor abstract and subclass it for each sensor

Answer

Use a static factory method in SensorDataProcessor to create sensors

Answer

Create a separate configuration file listing sensors and use reflection to instantiate them

Question 12

A junior developer created a class 'BankAccount' with public fields for balance and account number. After deployment, users are able to set negative balances, causing issues. Which OOP principle should have been applied to prevent this?

Accepted Answer

Encapsulation. Option C is correct because encapsulation would make the balance field private and provide a setter method that validates the value. Option A is wrong because polymorphism deals with method behavior, not data hiding. Option B is wrong because inheritance is about reusing code, not securing data. Option D is wrong because abstraction is about hiding complexity, not validation.

Answer

Inheritance

Answer

Abstraction

Answer

Polymorphism

Question 13

In a Java application, a class 'OrderProcessor' contains a method that processes orders. The method currently handles multiple responsibilities: validating order data, calculating totals, updating inventory, and sending notifications. The team wants to refactor this method to follow the Single Responsibility Principle. Which action should they take?

Accepted Answer

Create separate classes or methods for each responsibility and compose them in OrderProcessor. Option A is correct because separating each responsibility into its own class or method and composing them in OrderProcessor adheres to SRP. Option B is wrong because merging into a superclass does not separate responsibilities. Option C is wrong because a single utility method with if-else still violates SRP. Option D is wrong because overriding in subclasses does not separate concerns within the same method.

Answer

Use a single utility method that uses if-else for each case

Answer

Override the method in subclasses for each responsibility

Answer

Merge all responsibilities into a superclass

Question 14

Which TWO statements are true about the 'super' keyword in Java?

Accepted Answer

It can be used to call a superclass method that has been overridden.. Option A is correct because super() invokes the superclass constructor. Option C is correct because super.method() calls an overridden superclass method. Option B is wrong because super cannot access private fields. Option D is wrong because super cannot invoke static methods directly. Option E is wrong because super cannot access private methods.

Answer

It can be used to access private methods of the superclass.

Answer

It can be used to access private fields of the superclass.

Answer

It can be used to invoke a static method of the superclass.

Question 15

Refer to the exhibit. What is the output?

Accepted Answer

Bark
Fetching. Option B is correct: The object is a Dog, so sound() prints "Bark". The cast to Dog is valid, so fetch() prints "Fetching". Option A would occur if sound() were not overridden. Option C and D are incorrect because no exception is thrown.

Answer

Bark
 (then throws ClassCastException)

Answer

Animal sound
 (then throws ClassCastException)

Answer

Animal sound
Fetching