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

Question 1

A developer writes: Object obj = new String("Hello"); System.out.println(obj.length()); What will be the output?

Accepted Answer

Compilation error. The code fails to compile because the reference variable 'obj' is of type Object, which does not have a length() method. The length() method is defined in the String class, not in Object. Since the compiler checks the declared type (Object) for method availability, it does not find length() and produces a compilation error.

Answer

null

Answer

Runtime exception

Answer

5

Answer

0

Question 2

Which of the following best demonstrates polymorphism in Java?

Accepted Answer

Using an interface reference to call a method on an implementing object. Polymorphism in Java allows an object to take multiple forms, typically achieved through inheritance and interfaces. Option B demonstrates this by using an interface reference to invoke a method on an implementing object, where the actual method executed is determined at runtime based on the object's class, not the reference type.

Answer

Overloading a method with different parameter lists

Answer

Using static methods

Answer

Overriding a method in a subclass

Answer

Using final methods

Question 3

A class that does not define any constructor has:

Accepted Answer

A default no-argument constructor. When a class declares no constructor at all, the Java compiler automatically inserts a default no-argument constructor whose access modifier matches the class's access modifier (public for a public class). This implicit constructor simply calls super() and performs no other initialization, allowing the class to be instantiated with new ClassName().

Answer

A private constructor

Answer

A public constructor with arguments

Answer

It cannot be instantiated

Answer

No constructor

Question 4

class Parent { void show() { System.out.print("Parent"); } }
class Child extends Parent { void show() { System.out.print("Child"); } }
public class Test { public static void main(String[] args) { Parent p = new Child(); p.show(); } }

What is the output?

Accepted Answer

Child. This is runtime polymorphism in Java. The variable p is of type Parent but references a Child object, so the JVM invokes the overridden show() method in Child at runtime. The output is therefore 'Child'.

Answer

Compilation error

Answer

No output

Answer

Parent

Answer

Runtime error

Question 5

Which TWO access modifiers allow access from a subclass in a different package?

Accepted Answer

protected. (protected) is correct because the protected access modifier allows access to members of a superclass by subclasses in different packages, provided the subclass inherits from the superclass. Option E (public) is also correct because public members are accessible from any class, regardless of package or inheritance.

Answer

private

Answer

static

Answer

default (no modifier)

Question 6

Which THREE are true about Java constructors?

Accepted Answer

A constructor cannot have a return type. Constructors in Java do not have a return type, not even void. If you attempt to add a return type to a constructor, the compiler treats it as a regular method, not a constructor, which can lead to unexpected behavior. This is a fundamental rule of Java syntax.

Answer

A constructor can be marked final

Answer

A constructor can be abstract

Question 7

Which TWO statements about interfaces in Java are true?

Accepted Answer

An interface can extend another interface. Option C is correct because an interface can extend one or more other interfaces using the extends keyword, inheriting their abstract methods (and default/static methods, subject to rules) to build interface hierarchies. Option E is correct because since Java 8, interfaces may declare default methods using the default keyword with a concrete body, allowing implementations to inherit behavior without breaking existing classes. Option A is wrong because interface fields are implicitly public static final constants, so they are not instance variables. Option B is wrong because an interface cannot implement another interface; it can only extend it (a class implements an interface). Option D is wrong because interface methods cannot be final — abstract methods cannot be final, and default/static methods also cannot be declared final in an interface.

Answer

An interface can have instance variables

Answer

An interface can implement another interface

Answer

An interface can have final methods

Question 8

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. In Java, a class without an access modifier (i.e., 'class Helper') has package-private (default) access, meaning it is only accessible within its own package. Since the other class is in a different package, it cannot access the Helper class at all, even if its methods are public. The compilation error occurs because the class itself is not visible.

Answer

The method is declared as final

Answer

The method is not static

Answer

The class is abstract

Question 9

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. Encapsulation is the correct answer (D) because the private field 'balance' is hidden from direct external access and can only be read or modified through the public methods getBalance() and setBalance(double), which control how the data is accessed. This bundling of data with methods that operate on it, while restricting direct access to the internal state, is the defining characteristic of encapsulation. Abstraction (A) is about exposing only essential behavior and hiding implementation complexity, which is related but not the specific mechanism shown here. Inheritance (B) involves deriving a class from a parent class to reuse or extend behavior, and polymorphism (C) involves treating objects of different types through a common interface, neither of which is demonstrated by private fields with public accessors.

Answer

Abstraction

Answer

Inheritance

Answer

Polymorphism

Question 10

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 11

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 (late binding) is the mechanism by which the JVM determines at runtime which overridden method to invoke based on the actual object type, not the reference type. When an Animal reference holds a Dog object and makeSound() is called, the Dog's override executes, which is the definition of dynamic binding.

Answer

Static binding

Answer

Encapsulation

Answer

Method overloading

Question 12

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. In Java, a default method in an interface provides an implementation that implementing classes inherit unless they override it. Circle does not override draw(), so it uses the interface's default implementation. Square overrides draw(), so its own implementation is invoked. Therefore, Circle uses the default and Square uses its own.

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 13

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

Accepted Answer

Allows polymorphic behavior. Option B is correct because inheritance enables polymorphic behavior: a subclass can override superclass methods, and a superclass reference can refer to subclass objects, so the overridden method invoked is resolved at runtime via dynamic dispatch. Option C is correct because inheritance promotes code reuse: common fields and methods defined in a superclass are inherited by subclasses, eliminating duplication of shared logic. Option A is not a benefit but a drawback, since inheritance tightly couples subclasses to the superclass implementation, making changes riskier. Option D is incorrect because encapsulation is achieved through access modifiers (private, protected, public) and getters/setters, not inheritance; in fact, inheritance can expose protected members. Option E is incorrect because inheritance can complicate debugging by adding layers and hidden method resolution, rather than simplifying it.

Answer

Increases coupling between classes

Answer

Enforces encapsulation

Answer

Simplifies debugging

Question 14

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

Accepted Answer

An interface can extend multiple interfaces. Option B is correct because Java interfaces support multiple inheritance of type: an interface declaration may use the extends keyword followed by a comma-separated list of several interfaces, e.g. interface C extends A, B {}. Option C is correct because since Java 8 an interface may declare static methods (e.g. static int helper() { ... }), which belong to the interface itself and must be invoked via the interface name, not through an implementing instance. Option D is correct because since Java 8 an interface may declare default methods using the default keyword with a body, allowing implementations to inherit behavior without overriding it. Option A is not correct because interfaces are abstract types and cannot be instantiated with new; you must instantiate a concrete implementing class (or an anonymous class). Option E is not correct because every field declared in an interface is implicitly public static final, so private instance fields are not permitted (private methods are allowed since Java 9, but not private fields).

Answer

An interface can be instantiated directly

Answer

An interface can have private fields

Question 15

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 a Discountable interface with calculateDiscount() and having each concrete product class (Electronics, Clothing, Food) implement it lets new product types add their own discount logic without modifying existing code, which is exactly the Open/Closed Principle (open for extension, closed for modification). Polymorphism dispatches calculateDiscount() to the appropriate subclass at runtime, so the existing discount calculation logic remains untouched when a new product type is introduced. Option B violates OCP because a single Product method with if-else type checks must be edited every time a new product type is added. Option C is wrong because reflection-based external handling is fragile, bypasses type safety, and still requires changes to the external handler for new types. Option D is wrong because a switch statement in a utility class centralizes type checks and must also be modified whenever a new product type appears.

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