OOP in Java: Inheritance, Polymorphism and Abstraction

Object-oriented programming (OOP) is the biggest topic in Java interviews, and it hides many "tricky" questions. This article follows them in the order interviewers usually ask.

The four pillars in Java

Overloading versus overriding

• Overloading: the same method name with different parameters in one class. The compiler picks the method at compile time. Changing only the return type is not enough.
• Overriding: a subclass supplies its own version of an inherited method with the same signature. The JVM picks the method at run time from the object's real class. This is runtime polymorphism.

Overriding rules: the method must be visible and not final, it may return a narrower (covariant) type, it cannot reduce access (a public method cannot become package-private), and it cannot throw broader checked exceptions. Always add @Override so the compiler checks the signature for you.

Static and private methods are not overridden, and fields are not polymorphic

Only instance methods take part in dynamic dispatch. static methods belong to the class, so a subclass method with the same signature hides the parent's method. private methods are not inherited at all. And fields are never polymorphic: a field access uses the variable's declared type.

public class Polymorphism {
    public static void main(String[] args) {
        Animal animal = new Dog();
        System.out.println(animal.speak());      // Woof     overriding: the object's real type decides
        System.out.println(animal.name);         // Animal   fields are not polymorphic: the variable's type decides
        System.out.println(Animal.kind());       // Animal   static methods belong to the class
        System.out.println(Dog.kind());          // Dog
    }
}

class Animal {
    String name = "Animal";
    String speak() { return "..."; }
    static String kind() { return "Animal"; }
}

class Dog extends Animal {
    String name = "Dog";                          // hides the field, does not override it
    @Override String speak() { return "Woof"; }
    static String kind() { return "Dog"; }        // hides the static method
}

Try it in the override versus hiding snippet.

Abstract class versus interface

Use an interface for a capability (, , ), and an abstract class when subclasses share state or code.

Can an abstract class have a constructor? Yes. It runs (through ) whenever a subclass object is created, and it initializes the shared state. You just cannot call on the abstract class itself.

Access modifiers

Encapsulation in practice

Keep fields and expose behaviour, so you can validate input now and change the internals later without breaking callers:

final, composition and Object

• on a variable means it cannot be reassigned, on a method it cannot be overridden, and on a class it cannot be extended ( is final).
• Composition ("has-a") is usually better than inheritance ("is-a"): it is more flexible and easier to test. Deep inheritance trees are brittle.
• Every class extends , which gives you , and . See equals and hashCode.

Practise

1. Remove from and change its parameter list. What does the compiler say now?
2. Write an abstract class with an abstract method and two subclasses.
3. Take the Fundamentals, Strings and OOP quiz.