Overriding and polymorphism

Overriding

class Notification {
    String send(String to, String text) { return "Sending to " + to; }
}
class Sms extends Notification {
    @Override
    String send(String to, String text) {
        return "SMS to " + to + ": " + text.substring(0, Math.min(160, text.length()));
    }
}
class Email extends Notification {
    @Override
    String send(String to, String text) { return "Email to " + to + " with subject"; }
}

Rules for overriding: the same name and parameter types; the return type must be the same or a subtype (a covariant return); the access cannot be more restrictive (a public method cannot become private); and it cannot throw broader checked exceptions. @Override makes the compiler verify all this.

Polymorphism and dynamic dispatch

Polymorphism ("many forms") lets one variable of a parent type refer to objects of different subclasses. When you call an overridden method, the JVM looks at the ACTUAL object at run time and runs that class's version. This is dynamic dispatch. The calling code does not need to know which subclass it has.

Notification[] channels = { new Sms(), new Email(), new Sms() };
for (Notification n : channels) {
    System.out.println(n.send("Asha", "Your order has shipped"));   // each runs ITS OWN send
}

Static type and dynamic type

In Notification n = new Sms(); the static type (the variable's declared type) is Notification; the dynamic type (the object's real class) is Sms. The compiler uses the static type to decide which methods you are ALLOWED to call; the JVM uses the dynamic type to decide which overridden version RUNS.

Notification n = new Sms();     // upcasting: automatic and always safe
n.send("Ravi", "Hi");           // runs Sms.send
// n.smsOnlyMethod();           // compile error: Notification has no such method

if (n instanceof Sms s) {       // pattern matching for instanceof (Java 16+)
    s.smsOnlyMethod();          // s is already cast to Sms
}
Email e = (Email) n;            // compiles, but throws ClassCastException at run time!

Overloading versus overriding

Static methods and fields are NOT polymorphic: a static method with the same signature in a subclass hides the parent's, and which one runs depends on the static type. Fields are also chosen by the static type. Only instance methods are dispatched dynamically.