Antwoord.

Geschiedenis van de vraag:

Polymorfisme is een van de sleutelprincipes van objectgeoriënteerd programmeren (OOP), dat in Java wordt ondersteund sinds de oprichting. Het stelt een object in staat zich op verschillende manieren te gedragen, afhankelijk van zijn feitelijke type tijdens de uitvoering van het programma, zelfs als een referentie van het basistype wordt gebruikt.

Probleem:

Zonder polymorfisme wordt de code inflexibel, en er verschijnen vaak overbodige constructies zoals switch-case of if-else voor het werken met objecten van verschillende typen. Dit maakt het onderhouden en uitbreiden van de code moeilijker. Polymorfisme lost het probleem van het schrijven van herhalende code voor verschillende types op.

Oplossing:

Polymorfisme in Java wordt geïmplementeerd via overerving en interfaces. Het stelt in staat:

een referentie van het oudertype kan wijzen naar een object van het kindtype;
geoverride methoden aan te roepen zonder de specifieke type van het object tijdens compilatie te weten.

Voorbeeldcode:

class Animal {
    void speak() { System.out.println("Animal spreekt"); }
}
class Dog extends Animal {
    @Override void speak() { System.out.println("Hond blaft"); }
}
class Cat extends Animal {
    @Override void speak() { System.out.println("Kat mauwt"); }
}
public class PolyDemo {
    public static void main(String[] args) {
        Animal a1 = new Dog();
        Animal a2 = new Cat();
        a1.speak(); // Hond blaft
        a2.speak(); // Kat mauwt
    }
}

Belangrijkste kenmerken:

Staat systemen toe om uitgebreid en gewijzigd te worden zonder bestaande code te veranderen.
Biedt losse koppeling tussen componenten.
Via polymorfisme worden ontwerp patronen geïmplementeerd (bijvoorbeeld, Strategy, Command).

Vragen met een valstrik.

Wat is het verschil tussen overloading en overriding van methoden in polymorfisme?

Overloading is het definiëren van meerdere methoden met dezelfde naam, maar met verschillende handtekeningen in één klasse. Overriding is het definiëren van een methode in een subclass met dezelfde handtekening als in de ouderklasse.

class Example {
    void foo(int x) {}
    void foo(String y) {} // dit is overloading
}
class Base { void foo() {} }
class Child extends Base {
    @Override void foo() {} // dit is overriding
}

Kan er polymorfisme zijn zonder overerving?

In de klassieke zin in Java - nee: polymorfisme vereist een hiërarchie van overerving of een geïmplementeerd interface.

Kun je methoden van een subclass aanroepen vanuit een referentie naar de ouderklasse?

Je kunt alleen methoden aanroepen die zijn gedefinieerd in de ouderklasse of zijn overridden in de subclass. Methoden die alleen in de subclass bestaan, kunnen niet worden aangeroepen zonder typecasting.

Animal a = new Dog();
a.speak(); // kan
// a.fetch(); // compilatiefout, zelfs als Dog een fetch() methode heeft

Typische fouten en antipatterns

Het overriding van methoden zonder @Override annotatie - de compiler vangt de mismatch van handtekeningen niet.
Typecasting zonder controle via instanceof, wat ClassCastException veroorzaakt.
Het gebruik van polymorfisme waar samenstelling eenvoudiger zou zijn.

Voorbeeld uit het leven

Negatief geval

In het project zijn er klassen Dog, Cat, Cow geïmplementeerd, maar de gebruikte code werkte direct met de types, waarbij methoden werden aangeroepen via expliciete casts en instanceof:

Voordelen:

Snelle implementatie van nieuwe diersoorten.

Nadelen:

Toenemende if-else.
Schending van OOP-principes.
Moeilijkheid bij schaling.

Positief geval

Overerving van Animal met virtuele speak(). Alle interactie verloopt via het basistype Animal.