Polymorfisme in Java: Uitgebreide Gids met Praktische Voorbeelden

Wat Is Polymorfisme in Java?

Polymorfisme is een kernconcept in Java's Objectgeoriënteerde Programmering (OOP). Het ontstaat wanneer klassen gekoppeld zijn door overerving, wat toelaat dat een enkele interface verschillende onderliggende vormen vertegenwoordigt. Het resultaat is dat een methode-aanroep verschillende implementaties kan oproepen, afhankelijk van het daadwerkelijke objecttype tijdens runtime.

Denk aan een smartphone die kan communiceren via spraakgesprek, tekst, afbeelding of e-mail. Het doel – communiceren – is hetzelfde, maar elke modus gedraagt zich anders. Dat is polymorfisme in alledaagse termen.

Wat Je Leert

• Definitie van Java polymorfisme
• Praktische OOP voorbeelden
• Methode overschrijven (overriding)
• Overloading vs. overriding
• Dynamische (run-time) polymorfisme
• Statische vs. dynamische polymorfisme
• Het super sleutelwoord

Java Polymorfisme in OOP: Een Voorbeeld

Beschouw een basisklasse Rekening die storten() en opnemen() aanbiedt. Twee subklassen, SpaarRekening en BetaalRekening, overerven deze methodes ongewijzigd omdat de operaties identiek zijn.

Anticiperen op Veranderende Vereisten

Wanneer een nieuwe functie – zoals een overdraft faciliteit – vereist is, kan een PrivilegedAccount subklasse opnemen() overschrijven om de nieuwe logica te bieden zonder bestaande subklassen aan te tasten. Dit demonstreert het onderhoudsvoordeel van polymorfisme.

Methode Overschrijven (Overriding) in Java

Overriding treedt op wanneer een subklasse zijn eigen implementatie levert van een methode die al gedefinieerd is in de superklasse. De methode-handtekening (naam, parameters, return type) moet exact overeenkomen.

Belangrijke Regels

• De overschreven methode mag bredere zichtbaarheid hebben (bijv. protected naar public) maar nooit nauwere.
• Return types moeten hetzelfde zijn of covariant.

Voorbeeld:

class Dokter {
    public void behandelPatiënt() {
        // algemene behandelingslogica
    }
}
class Chirurg extends Dokter {
    @Override
    public void behandelPatiënt() {
        // gespecialiseerde chirurgische behandeling
    }
}
public class Run {
    public static void main(String[] args) {
        Dokter dokter = new Dokter();
        dokter.behandelPatiënt(); // voert Dokter.behandelPatiënt() uit
        Chirurg chirurg = new Chirurg();
        chirurg.behandelPatiënt(); // voert Chirurg.behandelPatiënt() uit
    }
}

Overloading vs. Overriding

void som(int a, int b);
void som(int a, int b, int c);
void som(float a, double b);

class X { int som() { ... } }
class Y extends X { @Override int som() { ... } }

Dynamische Polymorfisme (Run-Time)

Wanneer een superklassenreferentie naar een subklasseobject wijst, lost de JVM de methode-aanroep op tijdens runtime. Dit is echte polymorfisme in actie.

Dokter dok = new Chirurg();
dok.behandelPatiënt(); // Voert Chirurg.behandelPatiënt() uit

De daadwerkelijk aangeroepen methode hangt af van het runtime-type van het object, niet het referentietype.

Statische vs. Dynamische Polymorfisme

Statische polymorfisme (overloading) wordt op compile-tijd opgelost, terwijl dynamische polymorfisme (overriding) op runtime wordt opgelost.

void som(int a, int b);
void som(float a, double b);

Dokter d = new Chirurg();
d.behandelPatiënt();

Het super Sleutelwoord Gebruiken

Wanneer een subklasse een superklasse methode wil uitbreiden, roept super de parent implementatie aan voordat het zijn eigen logica toevoegt.

class Chirurg extends Dokter {
    @Override
    public void behandelPatiënt() {
        super.behandelPatiënt(); // basislogica
        // chirurg-specifieke logica
    }
}

Op dezelfde manier kan super toegang krijgen tot protected of publieke velden van de superklasse.

Praktisch Voorbeeld: Inheritance, Polymorfisme & Super

Kopieer de onderstaande code in je IDE en observeer de output.

public class Test {
    public static void main(String[] args) {
        X x = new X();
        Y y = new Y();
        y.m2(); // Uncomment om inheritance effecten te zien
        // x.m1();
        // y.m1();
        // x = y; // parent referentie naar child object
        // x.m1();
        // y.a = 10; // error: a is private
    }
}
class X {
    private int a;
    int b;
    public void m1() {
        System.out.println("Dit is methode m1 van klasse X");
    }
}
class Y extends X {
    int c;
    @Override
    public void m1() {
        System.out.println("Dit is methode m1 van klasse Y");
    }
    public void m2() {
        super.m1();
        System.out.println("Dit is methode m2 van klasse Y");
    }
}

Belangrijkste Punten

• Polymorfisme stelt objecten in staat meerdere vormen aan te nemen door overerving.
• Methode overriding wijzigt gedrag in subklassen terwijl de handtekening behouden blijft.
• Dynamische polymorfisme lost methode-aanroepen op tijdens runtime, wat flexibele code mogelijk maakt.
• Statische polymorfisme (overloading) is compile-time, terwijl dynamische polymorfisme run-time is.
• Het super sleutelwoord laat subklassen parent methodes aanroepen of protected leden benaderen.