Inheritance and Polymorphism Interview Questions

Overloading is several methods with the same name and different parameter lists, chosen at compile time from the argument types. Overriding is a subclass replacing an inherited method with the same signature, chosen at runtime from the object.

public class Main {
    public static void main(String[] args) {
        Printer p = new LoudPrinter();
        p.print(7);
        p.print("hi");
    }
}

class Printer {
    void print(int x) { System.out.println("int " + x); }

    void print(String s) { System.out.println("String " + s); }
}

class LoudPrinter extends Printer {
    @Override
    void print(String s) { System.out.println("STRING " + s.toUpperCase()); }
}

It prints int 7 and STRING HI. See method overloading.

Operator overloading lets a class define what an operator such as + or == does for its objects. C++ (operator+) and Python (__add__, __eq__) support it. Java does not, apart from the built-in + on strings, so you call methods such as BigDecimal.add.

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __eq__(self, other):
        return isinstance(other, Vector) and (self.x, self.y) == (other.x, other.y)

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

print(Vector(1, 2) + Vector(3, 4), Vector(1, 2) == Vector(1, 2))

It prints Vector(4, 6) True. See C++ operator overloading.

Methods are polymorphic, fields are not. a.name is resolved at compile time from the reference type Animal, while a.getName() is overridden and dispatched at runtime to Dog. A subclass field with the same name hides the parent's, and both exist in the object. It compiles, and it is almost always a bug.

Static methods are hidden, not overridden. A static call binds at compile time to the reference type, so p.who() calls Parent.who(), while the instance method me() is dispatched at runtime to Child. @Override on a static method is a compile error.

null matches both overloads, and Java picks the most specific: String is a subtype of Object, so show(String) wins.

Follow-up: what if you add show(Integer i)? The call stops compiling as ambiguous, because neither String nor Integer is more specific; choose with show((Integer) null).

If D inherits from B and C, and both override a method of A, which version does D get? Java avoids this for classes by allowing one superclass. Interface default methods can still clash, and then the class must override and choose:

public class Main {
    public static void main(String[] args) {
        System.out.println(new SmartPhone().click());
    }
}

interface Camera {
    default String click() { return "photo"; }
}

interface Phone {
    default String click() { return "call"; }
}

class SmartPhone implements Camera, Phone {
    @Override
    public String click() { return Camera.super.click() + " + " + Phone.super.click(); }
}

It prints photo + call; without the override it does not compile. Python resolves the diamond with the MRO.

Base's constructor runs before Derived's field initializers, but the object is already a Derived, so describe() dispatches to the override and reads name while it is still null. C++ differs: during Base's constructor a virtual call runs Base::describe(). The rule from Effective Java: constructors must not call overridable methods.

Upcasting treats a subclass object as its parent type (Animal a = new Dog();) and is always safe. Downcasting goes back (Dog d = (Dog) a;) and throws ClassCastException if the object is not that type. instanceof checks first, and since Java 16 binds a variable:

public class Main {
    public static void main(String[] args) {
        Object[] things = { "hello", 42, 3.5 };
        for (Object o : things) {
            if (o instanceof String s) {
                System.out.println("String of length " + s.length());
            } else if (o instanceof Integer i) {
                System.out.println("Integer doubled " + (i * 2));
            } else {
                System.out.println("Other: " + o.getClass().getSimpleName());
            }
        }
    }
}

It prints String of length 5, Integer doubled 84, Other: Double.

final means it cannot change further. A final variable is assigned once, a final method cannot be overridden, and a final class cannot be extended (String, Integer). The trap: a final reference is not an immutable object. final List<String> list cannot point to another list, but list.add("x") still works.

A covariant return type lets an overriding method return a subtype of the parent method's return type (Java 5 and later).

class Animal {
    Animal reproduce() { return new Animal(); }
}

class Dog extends Animal {
    @Override
    Dog reproduce() { return new Dog(); }   // Dog is a subtype of Animal
}

Callers holding a Dog get a Dog back without a cast. Parameters have no such freedom: changing a parameter type creates an overload, not an override.