1Z0-811 Object-Oriented Programming — 20 Questions

Question 1

Given: abstract class Shape { abstract void draw(); } class Circle extends Shape { void draw() {} } Which is true?

Accepted Answer

Circle must override draw(). Circle is a concrete class that extends the abstract class Shape, which declares the abstract method draw(). A concrete subclass of an abstract class must provide an implementation for all inherited abstract methods, unless the subclass is also declared abstract. Circle provides an implementation of draw() with an empty body, which satisfies the override requirement.

Answer

Shape cannot have a constructor

Answer

Shape s = new Shape(); is valid

Answer

draw() must be public in Circle

Question 2

What is the output of: System.out.println(new Manager("Alice", 5).getName());

Accepted Answer

Alice. The code creates a new Manager object with the name "Alice" and a level of 5, then calls getName() on it. Assuming Manager extends a class (likely Employee) that has a constructor setting the name field via super(name), getName() returns the stored name "Alice". The code compiles and runs without exception, printing "Alice".

Answer

Runtime exception

Answer

Compilation fails

Answer

null

Question 3

What is the result of: new Document().print();

Accepted Answer

Compilation fails. The correct answer is C: Compilation fails, because java.awt.print.Printable is an interface and cannot be instantiated with new Printable(); attempting to do so produces a compile-time error such as 'Printable is abstract; cannot be instantiated'. The expression in the question, new Document().print(), is also invalid since java.awt.print.Document does not exist and print() is not a method on a Document object, so the code cannot compile. Option A is wrong because Printable is an interface, not a concrete class that can be instantiated. Option B is wrong because the failure occurs at compile time, not as a runtime exception. Option D is wrong because Showable is not a standard Java type relevant to this code.

Answer

Printable

Answer

Runtime exception

Answer

Showable

Question 4

Refer to the exhibit. What is the output when the following code is executed? Vehicle v = new Car(); v.accelerate(); System.out.println(v.speed);

Accepted Answer

20. The code uses polymorphism: `Vehicle v = new Car();` creates a `Car` object but assigns it to a `Vehicle` reference. When `v.accelerate()` is called, Java uses dynamic method dispatch to invoke the overridden `accelerate()` method in `Car`. That method likely sets `speed` to 20 (as per the exhibit), so `v.speed` prints 20. The key is that the actual object type (Car) determines the method behavior, not the reference type.

Answer

10

Answer

0

Answer

Compilation error

Question 5

Refer to the exhibit. Why does the code fail to compile?

Accepted Answer

Cannot instantiate an abstract class. The code fails to compile because it attempts to instantiate an abstract class. In Java, abstract classes cannot be instantiated directly with the new keyword; they are meant to be subclassed. The error occurs at the point where new Animal() is called, assuming Animal is abstract.

Answer

Animal must be declared as interface

Answer

The main method is in the wrong class

Answer

The sound() method is not defined

Question 6

Consider the following interface: public interface Drawable { void draw(); } A developer implements Drawable in class Circle. Which statement about the implementation is correct?

Accepted Answer

The draw method must be declared public. In Java, when a class implements an interface, it must provide implementations for all abstract methods, and those implementations must be declared public because interface methods are implicitly public. The draw method in the Circle class must therefore be public. The other options are either incorrect or not necessarily true.

Answer

Both A and D

Answer

The class must be abstract if it does not provide body for draw

Answer

The draw method can have a body in the interface

Answer

The draw method must be declared final

Question 7

Which statement about abstract classes and interfaces is true in Java?

Accepted Answer

An abstract class can have concrete methods. An abstract class in Java can contain concrete (non-abstract) methods with full implementations, which subclasses can inherit or override. This is a key distinction from interfaces (prior to Java 8), which could only declare abstract methods. Abstract classes cannot be instantiated directly, but they provide a partial implementation that concrete subclasses complete.

Answer

Both B and D

Answer

An interface can have instance variables

Answer

An abstract class can be instantiated

Answer

An interface can have constructor

Question 8

Refer to the exhibit.

What is the output?

Accepted Answer

Vehicle. The correct answer is Vehicle because the code uses a static method call on a variable that is null. In Java, invoking a static method through an instance reference (even a null one) does not cause a NullPointerException; the compiler resolves the call to the class based on the reference type. Since the variable is declared as Vehicle, the static method from Vehicle is invoked, printing 'Vehicle'. The null value is irrelevant for static method dispatch.

Answer

null

Answer

Compilation error

Answer

Car

Answer

Runtime error

Question 9

Refer to the exhibit.

What is the output?

Accepted Answer

Photo. Based on the exhibit (a Java inheritance/polymorphism scenario), the correct output is 'Photo.' The code likely involves a superclass reference pointing to a subclass object, and the overridden method in the subclass returns 'Photo,' demonstrating dynamic method dispatch at runtime.

Answer

Runtime error

Answer

No output

Answer

Compilation error

Answer

Document

Question 10

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 11

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 12

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

Accepted Answer

Encapsulation. Encapsulation (B) is a fundamental OOP principle because it bundles data (attributes) and the methods that operate on that data within a single class, while restricting direct external access through access modifiers such as private, protected, and public. Inheritance (D) is fundamental because it lets a subclass (derived class) acquire the fields and methods of a superclass (base class), typically expressed with the extends or inherits keyword, promoting code reuse and an is-a relationship. Polymorphism (E) is fundamental because it allows the same method invocation to behave differently depending on the actual object type, implemented via method overriding (runtime/dynamic dispatch) or overloading (compile-time). Compilation (A) is not an OOP principle but a language translation process performed by a compiler (e.g., javac), and Modularization (C) is a broader software-design technique for decomposing systems into modules, not one of the core OOP pillars of encapsulation, inheritance, and polymorphism.

Answer

Compilation

Answer

Modularization

Question 13

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

Accepted Answer

The constructor parameter shadows the field, causing name to remain null. In the exhibited class, the constructor parameter is named the same as the instance field (e.g., both named 'name'), so the assignment 'name = name' assigns the parameter to itself, leaving the instance field at its default value of null. To fix this, the constructor must use 'this.name = name' to disambiguate the field from the parameter. This is a classic variable shadowing bug in Java.

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 14

Refer to the exhibit. What is the output?

Accepted Answer

Bark
Fetching. The code likely involves a superclass Animal with a method sound() returning 'Animal sound' and a subclass Dog overriding it to return 'Bark'. When calling sound() on a Dog instance, dynamic method dispatch invokes Dog's version, printing 'Bark'. Then a separate method fetch() on Dog prints 'Fetching'. No ClassCastException occurs because the object is actually a Dog.

Answer

Bark
 (then throws ClassCastException)

Answer

Animal sound
 (then throws ClassCastException)

Answer

Animal sound
Fetching

Question 15

A company develops a payroll system in Java with a hierarchy: Employee, Manager (extends Employee), and Director (extends Manager). Each class overrides a method getDetails() that returns a string with employee information. Employee's getDetails() returns name and ID. Manager's getDetails() adds department. Director's getDetails() adds division. The system uses a single method printDetails(Employee e) that calls e.getDetails(). After a recent deployment, the system prints only the name and ID for all employees, even for managers and directors. The code review reveals that Employee's getDetails() is declared with default (package-private) access, while the overridden versions in Manager and Director are public. The printDetails method and the Manager/Director classes are in different packages. What is the most likely cause and the correct solution?

Accepted Answer

Change the access modifier of getDetails() in Employee to public (or protected).. The most likely cause is that Employee.getDetails() has default (package-private) access, so it is not visible or overridable outside its package. Since printDetails() and the Manager/Director classes are in different packages, the method call resolves to Employee's version rather than the overridden public versions. Changing Employee's method to public (or protected) restores proper polymorphism.

Answer

Modify printDetails() to accept Manager or Director objects instead of Employee.

Answer

Add @Override annotation to the overridden methods in Manager and Director.

Answer

Declare getDetails() in Employee as final to ensure consistent behavior.

Question 16

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?

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 17

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 18

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 19

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 20

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