What is the difference between compile-time and runtime polymorphism?

Think of a railway announcement. Before the train leaves, the station prints a timetable that says "Platform 3: Train to Patna". That decision is fixed in advance from the information on paper. That is compile-time polymorphism: the compiler looks at the types written in your code and decides which method to call before the program ever runs.

Now think of the ticket checker who walks in and asks "who are you?" A student gets a concession check, a senior citizen a different check, a regular passenger a third. The checker decides only after seeing the actual person. That is runtime polymorphism: the JVM looks at the real object and picks its version of the method.

class Printer {
    String print(Object o) { return "Object"; }
    String print(String s) { return "String"; }
}

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

class Dog extends Animal {
    String name = "dog";
    @Override String sound() { return "Woof"; }
    static String kind() { return "Dog"; }
}

public class Poly {
    public static void main(String[] args) {
        Object o = "hello";
        System.out.println(new Printer().print(o));  // prints: Object   (chosen from declared type)

        Animal a = new Dog();
        System.out.println(a.sound());               // prints: Woof     (chosen from actual object)
        System.out.println(a.name);                  // prints: animal   (fields are not polymorphic)
        System.out.println(a.kind());                // prints: Animal   (static: picked from declared type)
    }
}

Even though o holds a String, the compiler only knows it as Object, so it picks print(Object). But a.sound() runs Dog's method, because overriding is decided by the real object.

Compile-time polymorphism

• Achieved with method overloading (and, in some languages, operator overloading; Java only overloads + for strings internally and does not let you define your own).
• The compiler looks at the method name and the declared types of the arguments and picks the best match. The choice is written into the bytecode.

Runtime polymorphism

• Achieved with method overriding, through inheritance or interfaces.
• The compiler checks that the method exists on the declared type, but the JVM chooses which implementation to run by looking at the actual class of the object. This is called dynamic dispatch or late binding.
• Only instance methods that can be overridden take part. static, private and final methods, and all fields, are bound at compile time.

Runtime polymorphism is what makes plug-in designs work. A List<PaymentMethod> holding UPI, card and net banking objects can be processed with one loop calling pay(). A logging library calls Logger.log() without knowing whether the output goes to a file or the console. Compile-time polymorphism makes APIs friendly, like String.valueOf accepting an int, a double, a char or an Object.

• Thinking overloads are chosen by the runtime type of the argument. Java uses single dispatch: only the object the method is called on is checked at runtime; arguments are matched at compile time.
• Expecting fields to behave like methods. Declaring a field with the same name in a child class creates a second, hidden field.
• Calling static method "overriding". It is method hiding.
• Saying runtime polymorphism is slow. Modern JVMs inline most of these calls when only one or two classes are actually seen at a call site.

• Why does print(o) call print(Object) when o holds a String?
• Can we achieve runtime polymorphism with data members?
• What is the difference between static binding and dynamic binding?
• What is double dispatch, and how does the Visitor pattern use it?