1Z0-811 Object-Oriented Programming Practice Test 1 — 15 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.