Polymorphie in Java: Umfassender Leitfaden mit praktischen Beispielen

Was ist Polymorphie in Java?

Polymorphie ist ein Kernkonzept in Javas objektorientierter Programmierung (OOP). Sie tritt auf, wenn Klassen durch Vererbung verknüpft sind und ein einzelnes Interface unterschiedliche zugrundeliegende Formen darstellen kann. Das Ergebnis ist, dass ein Methodenaufruf je nach tatsächlichem Objekttyp zur Laufzeit unterschiedliche Implementierungen aufrufen kann.

Denken Sie an ein Smartphone, das per Sprachanruf, Text, Bild oder E-Mail kommunizieren kann. Das Ziel – Kommunikation – ist dasselbe, aber jeder Modus verhält sich anders. Das ist Polymorphie im Alltag.

Was Sie lernen werden

• Definition von Java Polymorphie
• Praktische OOP-Beispiele
• Methodenüberschreibung (Overriding)
• Überladen vs. Überschreiben
• Dynamische (Laufzeit-)Polymorphie
• Statische vs. dynamische Polymorphie
• Das super-Schlüsselwort

Java Polymorphie in OOP: Ein Beispiel

Betrachten Sie eine Basisklasse Account, die deposit() und withdraw() anbietet. Zwei Unterklassen, SavingsAccount und CheckingAccount, erben diese Methoden unverändert, da die Operationen identisch sind.

Anpassung an sich ändernde Anforderungen

Wenn eine neue Funktion – wie eine Überziehungsmöglichkeit – erforderlich ist, kann eine PrivilegedAccount-Unterklasse withdraw() überschreiben, um die neue Logik bereitzustellen, ohne bestehende Unterklassen zu berühren. Dies demonstriert den Wartbarkeitsvorteil der Polymorphie.

Methodenüberschreibung in Java

Überschreiben tritt auf, wenn eine Unterklasse ihre eigene Implementierung einer bereits in der Superklasse definierten Methode bereitstellt. Die Methodensignatur (Name, Parameter, Rückgabetyp) muss exakt übereinstimmen.

Wichtige Regeln

• Die überschriebene Methode darf eine größere Sichtbarkeit haben (z. B. protected zu public), aber nie schmalere.
• Rückgabetypen müssen identisch oder kovariant sein.

Beispiel:

class Doctor {
    public void treatPatient() {
        // gemeinsame Behandlungslogik
    }
}
class Surgeon extends Doctor {
    @Override
    public void treatPatient() {
        // spezialisierte chirurgische Behandlung
    }
}
public class Run {
    public static void main(String[] args) {
        Doctor doctor = new Doctor();
        doctor.treatPatient(); // führt Doctor.treatPatient() aus
        Surgeon surgeon = new Surgeon();
        surgeon.treatPatient(); // führt Surgeon.treatPatient() aus
    }
}

Überladen vs. Überschreiben

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

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

Dynamische Polymorphie (Laufzeit)

Wenn eine Superklassenreferenz auf ein Unterklassenobjekt zeigt, löst die JVM den Methodenaufruf zur Laufzeit auf. Das ist echte Polymorphie in Aktion.

Doctor doc = new Surgeon();
doc.treatPatient(); // Führt Surgeon.treatPatient() aus

Die tatsächlich aufgerufene Methode hängt vom Laufzeittyp des Objekts ab, nicht vom Referenztyp.

Statische vs. Dynamische Polymorphie

Statische Polymorphie (Überladen) wird zur Kompilierzeit aufgelöst, während dynamische Polymorphie (Überschreiben) zur Laufzeit aufgelöst wird.

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

Doctor d = new Surgeon();
d.treatPatient();

Verwendung des super-Schlüsselworts

Wenn eine Unterklasse eine Superklassenmethode erweitern muss, ruft super die Elternimplementierung auf, bevor sie ihre eigene Logik hinzufügt.

class Surgeon extends Doctor {
    @Override
    public void treatPatient() {
        super.treatPatient(); // Basismethode
        // chirurgenspezifische Logik
    }
}

Ebenso kann super auf geschützte oder öffentliche Felder der Superklasse zugreifen.

Praxisbeispiel: Vererbung, Polymorphie & Super

Kopieren Sie den folgenden Code in Ihre IDE und beobachten Sie die Ausgabe.

public class Test {
    public static void main(String[] args) {
        X x = new X();
        Y y = new Y();
        y.m2();
        // Einkommentieren, um Vererbungseffekte zu sehen
        // x.m1();
        // y.m1();
        // x = y; // Elternreferenz auf Kindobjekt
        // x.m1();
        // y.a = 10; // Fehler: a ist privat
    }
}
class X {
    private int a;
    int b;
    public void m1() {
        System.out.println("This is method m1 of class X");
    }
}
class Y extends X {
    int c;
    @Override
    public void m1() {
        System.out.println("This is method m1 of class Y");
    }
    public void m2() {
        super.m1();
        System.out.println("This is method m2 of class Y");
    }
}

Wichtigste Erkenntnisse

• Polymorphie erlaubt Objekten, durch Vererbung multiple Formen anzunehmen.
• Methodenüberschreibung ändert Verhalten in Unterklassen bei Beibehaltung der Signatur.
• Dynamische Polymorphie löst Methodenaufrufe zur Laufzeit auf und ermöglicht flexiblen Code.
• Statische Polymorphie (Überladen) ist Compile-Time, dynamische Polymorphie ist Run-Time.
• Das super-Schlüsselwort lässt Unterklassen Elternmethoden aufrufen oder geschützte Member zugreifen.