Course: Core Java Training
Topic: Practicing Object-Oriented Programming (OOP), Inheritance, Polymorphism, and Abstraction Questions
Course Link: JustAcademy Core Java Training
Demo Link: Register for a Free Course Demo
Website: JustAcademy Official Website
Object-Oriented Programming (OOP) is a programming approach in which software is organized around classes and objects. Java uses OOP principles to create reusable, maintainable, and modular applications. Practicing OOP questions helps developers understand how objects interact, how classes share behavior, and how programs can be designed with flexibility.
The four major pillars of OOP are encapsulation, inheritance, polymorphism, and abstraction. This topic focuses particularly on inheritance, polymorphism, and abstraction while revising the supporting concepts needed to solve Core Java interview and programming questions.
A class is a blueprint that defines the fields, constructors, and methods that its objects can use. It describes the data an object stores and the operations it performs.
An object is an instance of a class. Each object can maintain its own instance field values and use the methods defined by its class.
class Student {
String name;
int marks;
void displayDetails() {
System.out.println("Name: " + name);
System.out.println("Marks: " + marks);
}
}
public class Main {
public static void main(String[] args) {
Student student = new Student();
student.name = "Aarav";
student.marks = 85;
student.displayDetails();
}
}Output:
Name: Aarav
Marks: 85Explanation: The Student class defines two fields and one method. The statement new Student() creates an object, and the reference variable student is used to access its fields and method.
| Concept | Meaning | Primary Benefit | Example |
|---|---|---|---|
| Encapsulation | Combining data and methods while controlling access to internal state. | Data protection and controlled modification. | Private bank balance with deposit and withdrawal methods. |
| Inheritance | Creating a class from an existing class. | Code reuse and specialization. | Car extends Vehicle. |
| Polymorphism | Using a common interface or parent type for different implementations. | Flexible and extensible behavior. | Different shapes implement their own area calculation. |
| Abstraction | Exposing essential operations while hiding implementation details. | Reduced complexity and clear contracts. | An abstract Shape class defines an area method. |
Inheritance allows a class to acquire accessible fields and methods from another class. The existing class is called the superclass or parent class, and the derived class is called the subclass or child class. Java uses the extends keyword for class inheritance.
class Animal {
void eat() {
System.out.println("Animal is eating");
}
}
class Dog extends Animal {
void bark() {
System.out.println("Dog is barking");
}
}
public class Main {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
dog.bark();
}
}Output:
Animal is eating
Dog is barkingExplanation: The Dog class inherits the accessible eat() method from Animal and also defines its own bark() method.
class LivingThing {
void grow() {
System.out.println("Living thing grows");
}
}
class Animal extends LivingThing {
void eat() {
System.out.println("Animal eats");
}
}
class Dog extends Animal {
void bark() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Dog dog = new Dog();
dog.grow();
dog.eat();
dog.bark();
}
}Output:
Living thing grows
Animal eats
Dog barksExplanation: Dog inherits accessible behavior from Animal and LivingThing through the inheritance chain.
The super keyword can access superclass members and invoke a superclass constructor. A call to super(), when used to invoke a constructor, must be the first statement in that constructor.
class Employee {
String name = "Employee";
void display() {
System.out.println("Parent class method");
}
}
class Manager extends Employee {
String name = "Manager";
void showDetails() {
System.out.println(super.name);
super.display();
System.out.println(this.name);
}
}
public class Main {
public static void main(String[] args) {
Manager manager = new Manager();
manager.showDetails();
}
}Output:
Employee
Parent class method
ManagerExplanation: super.name refers to the inherited field, super.display() calls the parent implementation, and this.name refers to the current object's field.
super keyword?extends keyword is used for class inheritance.super can refer to superclass members and invoke a superclass constructor.Polymorphism means “many forms.” In Java, it allows the same method name or common parent-type reference to work with different behaviors. The two common forms taught in Core Java are compile-time polymorphism through method overloading and runtime polymorphism through method overriding.
Method overloading occurs when a class declares methods with the same name but different parameter lists. The parameter lists must differ in their number, types, or order of types. Changing only the return type is not sufficient.
class Calculator {
int add(int a, int b) {
return a + b;
}
int add(int a, int b, int c) {
return a + b + c;
}
double add(double a, double b) {
return a + b;
}
}
public class Main {
public static void main(String[] args) {
Calculator calculator = new Calculator();
System.out.println(calculator.add(10, 20));
System.out.println(calculator.add(10, 20, 30));
System.out.println(calculator.add(2.5, 3.5));
}
}Output:
30
60
6.0Explanation: The compiler selects the applicable overloaded method based on the arguments supplied at the call site.
Method overriding occurs when a subclass provides a compatible implementation of an inherited instance method. At runtime, Java selects the overridden implementation according to the actual object's class.
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
class Cat extends Animal {
@Override
void sound() {
System.out.println("Cat meows");
}
}
class Dog extends Animal {
@Override
void sound() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Animal animal1 = new Cat();
Animal animal2 = new Dog();
animal1.sound();
animal2.sound();
}
}Output:
Cat meows
Dog barksExplanation: Both variables have the declared type Animal, but they refer to different objects. The overridden method that executes is determined by the actual object type.
Dynamic method dispatch is the runtime mechanism Java uses to select an overridden instance method. It enables flexible designs in which code works with a superclass or interface type without needing to know the precise implementation in advance.
class Payment {
void pay() {
System.out.println("Generic payment");
}
}
class CardPayment extends Payment {
@Override
void pay() {
System.out.println("Payment by card");
}
}
class UpiPayment extends Payment {
@Override
void pay() {
System.out.println("Payment by UPI");
}
}
public class Main {
public static void main(String[] args) {
Payment payment;
payment = new CardPayment();
payment.pay();
payment = new UpiPayment();
payment.pay();
}
}Output:
Payment by card
Payment by UPIExplanation: The Payment reference can point to different subclass objects. Each object's implementation of pay() is executed at runtime.
| Feature | Overloading | Overriding |
|---|---|---|
| Purpose | Same method name with different parameter lists. | Provide a specialized implementation of an inherited instance method. |
| Relationship | Can occur in the same class or across inherited methods. | Requires inheritance or an implementation relationship. |
| Parameter list | Must differ. | Must be compatible with the inherited method's signature. |
| Selection | Primarily resolved at compile time. | Overridden instance implementation is selected at runtime. |
| Return type | Cannot distinguish overloads by itself. | Must be the same or a permitted covariant return type. |
| Common annotation | No special annotation is required. | @Override helps the compiler verify the intention. |
@Override annotation useful?Abstraction exposes essential operations while hiding unnecessary implementation details. It allows a programmer to define what an object should do without requiring every caller to know how the behavior is implemented.
Java supports abstraction through abstract classes and interfaces. An abstract class can contain abstract methods, concrete methods, fields, and constructors. An interface defines a contract and can also include permitted default, static, and private methods in modern Java.
An abstract class is declared with the abstract keyword and cannot be instantiated directly. An abstract method declares a method signature without providing a method body; a concrete subclass must implement inherited abstract methods unless that subclass is also abstract.
abstract class Shape {
abstract double calculateArea();
void display() {
System.out.println("Calculating shape area");
}
}
class Rectangle extends Shape {
private double length;
private double width;
Rectangle(double length, double width) {
this.length = length;
this.width = width;
}
@Override
double calculateArea() {
return length * width;
}
}
public class Main {
public static void main(String[] args) {
Shape shape = new Rectangle(5, 4);
shape.display();
System.out.println("Area: " + shape.calculateArea());
}
}Output:
Calculating shape area
Area: 20.0Explanation: Shape defines the required operation, while Rectangle provides the specific area calculation. A Shape reference can point to a Rectangle object.
An interface defines a contract that implementing classes agree to follow. A class can implement multiple interfaces, which provides a way to combine capabilities without multiple class inheritance.
interface Printable {
void print();
}
interface Scannable {
void scan();
}
class MultiFunctionPrinter implements Printable, Scannable {
@Override
public void print() {
System.out.println("Printing document");
}
@Override
public void scan() {
System.out.println("Scanning document");
}
}
public class Main {
public static void main(String[] args) {
MultiFunctionPrinter printer = new MultiFunctionPrinter();
printer.print();
printer.scan();
}
}Output:
Printing document
Scanning documentExplanation: MultiFunctionPrinter implements both Printable and Scannable, so it supplies implementations for both required methods.
| Feature | Abstract Class | Interface |
|---|---|---|
| Declaration | Uses the abstract class syntax. |
Uses the interface keyword. |
| Instantiation | Cannot be instantiated directly. | Cannot be instantiated directly. |
| Constructors | Can have constructors. | Cannot declare constructors. |
| Instance state | Can have instance fields. | Fields are implicitly public, static, and final. |
| Methods | Can contain abstract and concrete instance methods. | Can contain abstract methods and permitted default, static, and private methods. |
| Inheritance | A class can extend only one class. | A class can implement multiple interfaces. |
| Best suited for | Related classes that share state or common implementation. | Defining capabilities or contracts that different classes can implement. |
The following example combines all three concepts in a small employee salary system. The abstract Employee class defines a common structure, subclasses inherit from it and implement their own salary calculation, and polymorphism allows the same reference type to work with different employee objects.
abstract class Employee {
private String name;
Employee(String name) {
this.name = name;
}
String getName() {
return name;
}
abstract double calculateSalary();
}
class FullTimeEmployee extends Employee {
private double monthlySalary;
FullTimeEmployee(String name, double monthlySalary) {
super(name);
this.monthlySalary = monthlySalary;
}
@Override
double calculateSalary() {
return monthlySalary;
}
}
class PartTimeEmployee extends Employee {
private int hoursWorked;
private double hourlyRate;
PartTimeEmployee(String name, int hoursWorked, double hourlyRate) {
super(name);
this.hoursWorked = hoursWorked;
this.hourlyRate = hourlyRate;
}
@Override
double calculateSalary() {
return hoursWorked * hourlyRate;
}
}
public class Main {
public static void main(String[] args) {
Employee[] employees = {
new FullTimeEmployee("Aarav", 50000),
new PartTimeEmployee("Meera", 80, 300)
};
for (Employee employee : employees) {
System.out.println(
employee.getName() + ": " + employee.calculateSalary()
);
}
}
}Output:
Aarav: 50000.0
Meera: 24000.0calculateSalary() method.super(name) to initialize the parent class's state.class A {
void show() {
System.out.println("A");
}
}
class B extends A {
@Override
void show() {
System.out.println("B");
}
}
public class Main {
public static void main(String[] args) {
A obj = new B();
obj.show();
}
}Question: What is the output?
Answer:
BReason: The reference type is A, but the actual object is B. Runtime method dispatch invokes B's overridden method.
class Demo {
void print(int value) {
System.out.println("Integer");
}
void print(String value) {
System.out.println("String");
}
}
public class Main {
public static void main(String[] args) {
Demo demo = new Demo();
demo.print(10);
demo.print("Java");
}
}Answer:
Integer
StringReason: The compiler selects an overloaded method based on the argument type.
abstract class Vehicle {
abstract void start();
}
class Bike extends Vehicle {
@Override
void start() {
System.out.println("Bike starts");
}
}
public class Main {
public static void main(String[] args) {
Vehicle vehicle = new Bike();
vehicle.start();
}
}Answer:
Bike startsReason: Bike implements the abstract method, and the Vehicle reference points to a Bike object.
class Parent {
String message = "Parent";
void display() {
System.out.println("Parent method");
}
}
class Child extends Parent {
String message = "Child";
@Override
void display() {
System.out.println("Child method");
}
}
public class Main {
public static void main(String[] args) {
Parent obj = new Child();
System.out.println(obj.message);
obj.display();
}
}Answer:
Parent
Child methodReason: Field access is determined by the reference's declared type, so obj.message refers to Parent's field. Overridden instance methods use runtime dispatch, so display() invokes Child's method.
class Calculator {
int calculate(int a, int b) {
return a + b;
}
double calculate(int x, int y) {
return x + y;
}
}Question: Is this code valid?
Answer: No. It causes a compilation error because the methods have identical parameter types. Changing only the return type does not create a valid overload.
Create a Person class with name and age fields. Create a Student subclass with a roll number. Add methods to display the details and demonstrate inheritance.
Create an abstract Shape class with an abstract calculateArea() method. Implement Circle and Rectangle classes and display their areas using Shape references.
Create a Payment parent class with a processPayment() method. Override it in CardPayment, UpiPayment, and CashPayment. Store the objects in an array of Payment references and call the method for each object.
Create an abstract Employee class with employee details and an abstract salary calculation method. Implement FullTimeEmployee and PartTimeEmployee subclasses with different salary calculation rules.
Create Printable and Shareable interfaces. Implement both in a Document class. Demonstrate how one object can provide multiple capabilities.
Create a Book parent class and subclasses such as PrintedBook and EBook. Override a method that displays the format-specific details. Use polymorphism to display a collection of books.
Create an abstract Vehicle class with a rental cost calculation method. Implement Car and Bike subclasses with different pricing rules. Use a Vehicle reference to calculate the cost for each type.
| Mistake | Why It Happens | How to Correct It |
|---|---|---|
| Extending multiple classes | Java class inheritance allows only one direct superclass. | Use interfaces for additional capabilities or composition for reusable behavior. |
| Overloading by return type alone | The parameter lists remain identical. | Change the parameter list to create a valid overload. |
| Forgetting to implement an abstract method | A concrete subclass has not fulfilled its inherited contract. | Implement the method or declare the subclass abstract. |
| Trying to instantiate an abstract class | Abstract classes are incomplete or intended to be specialized. | Create an instance of a concrete subclass and use the abstract type as a reference if appropriate. |
| Reducing method visibility while overriding | The overriding method violates the access rules. | Keep the same or broader accessibility. |
| Using static methods to demonstrate runtime overriding | Static methods are hidden, not overridden through instance dispatch. | Use instance methods to demonstrate runtime polymorphism. |
| Confusing fields with overridden methods | Fields and instance methods use different resolution rules. | Remember that fields are selected by reference type, while overridden instance methods use runtime dispatch. |
| Incorrect constructor chaining | The superclass constructor is not called correctly. | Use a valid super(...) call as the first statement when explicitly invoking a superclass constructor. |
@Override to catch mistakes in overriding declarations.Answer: Inheritance establishes a relationship through which a subclass acquires accessible behavior from a superclass. Polymorphism allows a common reference or method name to represent different behaviors. Inheritance can support runtime polymorphism through method overriding.
Answer: No. Constructors are not inherited, so they cannot be overridden. A subclass constructor can call a superclass constructor using super(...).
Answer: Yes. A class can be declared abstract even when it contains no abstract methods. This prevents direct instantiation and can communicate that the class is intended to serve as a base type.
Answer: Yes. An interface can extend one or more interfaces. A class implements an interface using the implements keyword.
Answer: It allows code to operate on a general parent type or interface while different implementations provide their own behavior. This reduces dependence on specific classes and makes systems easier to extend.
Answer: An IS-A relationship is typically represented by inheritance or interface implementation, such as Dog being an Animal. A HAS-A relationship describes composition or aggregation, such as a Car having an Engine.
Answer: No. A private method is not inherited as an overridable method. A same-named method in a subclass is a separate declaration.
Answer: The subclass inherits the accessible implementation and can use it unless it is otherwise inaccessible or restricted.
Answer: Yes. An abstract class can leave some interface methods unimplemented. A concrete subclass must implement the remaining required methods.
Answer: Programming to an interface reduces coupling to concrete implementations, making it easier to replace implementations, test components, and extend application behavior.
extends correctly.super and this are used.Practicing OOP, inheritance, polymorphism, and abstraction questions builds a strong foundation for Core Java programming. Inheritance supports reuse, polymorphism supports flexible behavior, and abstraction separates a clear contract from implementation details. Together with encapsulation, these principles help developers create maintainable and extensible applications.
For effective preparation, write each example yourself, predict its output, compile it, and explain why the result occurs. Repeated practice with coding exercises and interview questions improves both conceptual understanding and problem-solving ability.
Strengthen your Java programming skills through structured Core Java training, practical examples, and guided learning.
