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

Question 1

Refer to the exhibit.

What is the likely cause?

Accepted Answer

The variable 'value' is not declared. The error message indicates that the variable 'value' has not been declared before use. In Java, every variable must be declared with a type and name before it can be referenced. The compiler cannot find a declaration for 'value' in the current scope, so it reports a 'cannot find symbol' error, which is the typical symptom of an undeclared variable.

Answer

The package is missing

Answer

The class name is misspelled

Answer

The variable 'value' is out of scope

Answer

The variable 'value' is declared but not initialized

Question 2

A developer wants to create a class that can be used to represent different types of vehicles (e.g., Car, Truck, Motorcycle) and each vehicle type should be able to start its own engine in a specific way. Which OOP concept should be used to allow the vehicle class to define a common interface while letting subclasses provide specific implementations?

Accepted Answer

Polymorphism. Polymorphism allows the Vehicle class to define a common method (e.g., startEngine()) that each subclass (Car, Truck, Motorcycle) overrides with its own specific implementation. When the method is called on a Vehicle reference, the JVM uses dynamic method dispatch at runtime to invoke the correct subclass version, enabling different engine-starting behaviors through a single interface.

Answer

Inheritance

Answer

Encapsulation

Answer

Abstraction

Question 3

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. The Helper class is declared with default (package-private) access because no access modifier is specified. Therefore, it is only accessible within the utils package. A class in a different package cannot access it, even if it tries to call a public method of that class, because the class itself is not accessible. The method's access modifier is irrelevant if the class is not accessible. Option A is incorrect because final does not affect access. Option B is incorrect because static is unrelated to access across packages. Option C is incorrect 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 4

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. Omposition (often implemented via the Strategy pattern), which allows the Report class to delegate format generation to separate strategy objects. This adheres to the Open/Closed Principle: the Report class is closed for modification but open for extension. Adding a new format only requires creating a new strategy class without altering the Report class. Option B (Composition) is correct. Option A (Method Overloading) is incorrect because it would require adding a new overloaded method for each format in the Report class, violating the goal of not modifying it. Option C (Inheritance) is incorrect because it would create a rigid hierarchy where each format is a subclass of Report, leading to tight coupling and difficulty in adding new formats without modifying existing code. Option D (Singleton) is incorrect because it ensures a single instance, which does not address the need for flexible format generation.

Answer

Method Overloading

Answer

Inheritance

Answer

Singleton

Question 5

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. Dynamic binding. Dynamic binding (runtime polymorphism) resolves method calls based on the actual object type at runtime, not the reference type. Here, the Animal reference holds a Dog object, so the Dog's overridden makeSound() is invoked. A is wrong because static binding occurs at compile-time for methods that cannot be overridden (e.g., static, final, or private). B is wrong because encapsulation hides data, not method dispatch. D is wrong because method overloading is compile-time polymorphism based on method signature.

Answer

Static binding

Answer

Encapsulation

Answer

Method overloading

Question 6

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. When a class implements an interface with a default method, the class inherits the default implementation unless it overrides the method. Circle does not override draw(), so it uses the default implementation from the Drawable interface. Square overrides draw(), so it uses its own version. Option B is incorrect because Square uses its own method, not the default. Option C is incorrect because Square does not use the default. Option D is incorrect because both classes 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 7

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

Accepted Answer

Allows polymorphic behavior. Options B and C are correct. Inheritance promotes code reuse by allowing subclasses to reuse fields and methods from superclasses, reducing redundancy. It also enables polymorphic behavior through method overriding, allowing objects to be treated as instances of their parent class. Option A is incorrect because inheritance actually increases coupling between classes, which is generally considered a disadvantage, not a benefit. Option D is incorrect because encapsulation is enforced through access modifiers (private, protected, public), not inheritance. Option E is incorrect because inheritance can actually complicate debugging by introducing dependencies across classes.

Answer

Increases coupling between classes

Answer

Enforces encapsulation

Answer

Simplifies debugging

Question 8

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

Accepted Answer

An interface can extend multiple interfaces. Options B, C, and D are true about interfaces in Java. An interface can extend multiple interfaces using the extends keyword. Since Java 8, interfaces can contain static methods (with body) and default methods. Option A is false because interfaces cannot be instantiated directly; they must be implemented by a class. Option E is false because interface fields are implicitly public static final; private fields are not permitted in interfaces (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 9

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

Accepted Answer

Encapsulation. Options B, D, and E are correct. Encapsulation, inheritance, and polymorphism are the three fundamental principles of Object-Oriented Programming. Option A (Compilation) is incorrect because compilation is a language process, not an OOP principle. Option C (Modularization) is incorrect because modularization is a design concept, not a foundational OOP principle.

Answer

Compilation

Answer

Modularization

Question 10

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

Accepted Answer

The constructor parameter shadows the field, causing name to remain null. The constructor parameter 'name' shadows the field 'name'. The assignment 'name = name' assigns the parameter to itself, leaving the field 'name' uninitialized (null). Option A is incorrect because constructors do not have a return type. Option C is incorrect because getName() returns a String, and it is fine to not be void. Option D is incorrect because the private field is accessible within the class.

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 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. Defining a Sensor interface and using dependency injection (e.g., passing sensor objects via constructor or setter) decouples the processor from concrete sensor classes, allowing new sensor types to be added without modifying the processor. Option A is wrong because creating subclasses for each sensor would still require modifying the processor if new sensor types are added. Option B is wrong because a static factory method still couples the processor to the factory and requires changes when new sensors are added. Option C is wrong because reflection is complex, error-prone, 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. Encapsulation involves making fields private and providing controlled access via methods. By encapsulating the balance field, a setter method can validate that the balance is not set to a negative value, preventing the issue. Option A (Inheritance) is about code reuse, not data hiding. Option C (Abstraction) is about hiding complexity, not enforcing validation. Option D (Polymorphism) is about methods behaving differently, not data protection.

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. It separates each responsibility into its own class or method and composes them in OrderProcessor, which adheres to the Single Responsibility Principle. Option A is wrong because a single utility method with if-else still violates SRP by handling multiple responsibilities. Option B is wrong because overriding in subclasses does not separate concerns within the same method; it shifts responsibilities but does not eliminate the violation. Option C is wrong because merging responsibilities into a superclass increases coupling and does not adhere to SRP.

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.. The 'super' keyword can be used to call a superclass method that has been overridden, using 'super.methodName()'. Option D is correct because 'super()' invokes the superclass constructor. Option A is wrong because 'super' cannot access private methods of the superclass. Option B is wrong because 'super' cannot access private fields. Option E is wrong because 'super' cannot invoke static methods directly; static methods are accessed via the class name.

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. The object is a Dog, so sound() prints 'Bark'. The cast to Dog is valid (the object is actually a Dog), so fetch() prints 'Fetching'. Options A, B, D are incorrect because no ClassCastException occurs; the Dog class overrides sound() and has fetch() method.

Answer

Bark
 (then throws ClassCastException)

Answer

Animal sound
 (then throws ClassCastException)

Answer

Animal sound
Fetching