What is polymorphism?

Question

Accepted Answer

**Polymorphism** ("many forms") lets a single interface work with different underlying types. The *same call* runs *different code* depending on the actual object — chosen at runtime. This is **subtype polymorphism**.

## One call, many behaviors

```java
class Animal { String speak() { return "..."; } }
class Dog extends Animal { String speak() { return "Woof"; } }
class Cat extends Animal { String speak() { return "Meow"; } }

Animal[] zoo = { new Dog(), new Cat() };
for (Animal a : zoo) {
    System.out.println(a.speak());   // Woof, then Meow
}                                    // same call, different result per type
```

The loop calls `a.speak()` without caring which animal it is — the runtime dispatches to the correct override.

## Why it's powerful

You can add a new `Animal` subtype later, and the loop above keeps working with **zero changes**. Code depends on the abstract type, not concrete classes.

```text
caller → Animal.speak()  ──dispatch──▶  Dog.speak()  OR  Cat.speak()
            (one interface)                  (many implementations)
```

## Pitfall

Don't confuse it with overloading (same method name, different *parameters*, resolved at compile time). True (subtype) polymorphism is resolved at *runtime* based on the object.

## Why it matters

Polymorphism is what makes OOP extensible: new behavior arrives as a new class, not as edits scattered through `if/else` chains.

It's the mechanism behind the Open/Closed Principle and most design patterns — you program to an interface and let runtime dispatch pick the implementation.