Wat is polymorfisme?

Question

Accepted Answer

**Polymorfisme** ("veel vormen") laat een enkele interface met verschillende onderliggende typen werken. *Dezelfde aanroep* voert *andere code* uit, afhankelijk van het werkelijke object — gekozen bij runtime. Dit is **subtype polymorfisme**.

## Eén aanroep, veel gedrag

```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
```

De lus roept `a.speak()` aan zonder te zorgen welk dier het is — de runtime stuurt naar de juiste override.

## Waarom het belangrijk is

Je kunt later een nieuw `Animal` subtype toevoegen, en de bovenstaande lus blijft werken met **nul wijzigingen**. Code is afhankelijk van het abstracte type, niet van concrete klassen.

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

## Valkuil

Verwar het niet met overloading (dezelfde methodenaam, verschillende *parameters*, opgelost bij compile-time). Echt (subtype) polymorfisme wordt opgelost bij *runtime* op basis van het object.

## Waarom het belangrijk is

Polymorfisme is wat OOP uitbreidbaar maakt: nieuw gedrag komt als een nieuwe klasse, niet als wijzigingen verspreid over `if/else` ketens.

Het is het mechanisme achter het Open/Closed Principle en de meeste ontwerppatronen — je programmeert naar een interface en laat runtime dispatch de implementatie kiezen.