Java Polymorphie verstehen: Guide & Beispiele

Stell dir vor, du entwickelst eine Gehaltsabrechnung für ein Unternehmen. Es gibt Mitarbeiter, Entwickler und Manager. Alle sollen ihr Gehalt berechnen können - aber die Formel ist jedes Mal anders. Entwickler bekommen Bonus für Überstunden, Manager eine Provision. Trotzdem willst du eine einzige Methode aufrufen: `berechneGehalt()`.

Genau das macht Java Polymorphie möglich. Das Wort kommt aus dem Griechischen und bedeutet "Vielgestaltigkeit". In Java bedeutet es: Ein Methodenaufruf kann unterschiedlich reagieren, je nachdem, welches Objekt gerade dahintersteckt.

Wenn du Java Klassen & Objekte bereits verstehst, bist du hier genau richtig. Polymorphie ist eines der mächtigsten Konzepte der objektorientierten Programmierung und hilft dir, Code flexibel und erweiterbar zu schreiben.

Was ist Java Polymorphie?

Java Polymorphie beschreibt die Fähigkeit eines Objekts, unter demselben Namen unterschiedliches Verhalten zu zeigen. Konkret heißt das: Eine Variable vom Typ "Mitarbeiter" kann technisch auf ein Entwickler-Objekt oder ein Manager-Objekt zeigen. Wenn du eine Methode aufrufst, führt Java automatisch die passende Version für das tatsächliche Objekt aus.

Stell dir vor, du hast eine Fernbedienung (die Variable) mit einem "Play"-Knopf (die Methode). Ob du damit einen Fernseher, eine Stereoanlage oder einen Streaming-Stick steuerst - der Knopf heißt immer "Play". Was passiert, entscheidet das Gerät zur Laufzeit.

Merke: Polymorphie erlaubt dir, Code zu schreiben, der mit verschiedenen Objekttypen funktioniert, ohne für jeden Typ eine eigene if-else-Abfrage zu schreiben.

Welche Arten von Polymorphie gibt es?

Java unterscheidet bei der Vielgestaltigkeit zwei Hauptformen, die zu unterschiedlichen Zeitpunkten ablaufen:

Was ist Compile-Time-Polymorphie (Overloading)?

Beim Method Overloading definierst du mehrere Methoden mit demselben Namen in einer Klasse. Der Compiler entscheidet bereits beim Übersetzen des Codes anhand der Parameter, welche Methode genutzt wird. Das ist statisch, also festgelegt, bevor das Programm startet.

public class Rechner {

  // Variante 1: zwei int-Parameter
  public int addiere(int a, int b) {
    return a + b;
  }

  // Variante 2: drei int-Parameter
  public int addiere(int a, int b, int c) {
    return a + b + c;
  }

  // Variante 3: zwei double-Parameter
  public double addiere(double a, double b) {
    return a + b;
  }
}

Der Compiler schaut sich beim Aufruf `addiere(1, 2)` die Argumente an und wählt die erste Variante. Wichtig zu wissen: Die Rückgabetedatenmenge (z. B. `int` vs. `double`) allein reicht nicht zur Unterscheidung, es müssen die Parameter sein.

Was ist Runtime-Polymorphie (Overriding)?

Hier wird es dynamisch. Bei Runtime-Polymorphie entscheidet Java erst während das Programm läuft, welche Methode ausgeführt wird. Das funktioniert durch Vererbung und das Überschreiben von Methoden. Das ist die Form, die meistens gemeint ist, wenn Entwickler von Polymorphie sprechen.

Oracle erklärt in seinem Tutorial sehr anschaulich, wie Unterklassen Verhalten erben und anpassen. Mehr dazu in der Oracle Doku zu Vererbung.

// Oberklasse
public class Mitarbeiter {

  public double berechneGehalt() {
    return 3000.0;
  }
}

// Unterklasse Entwickler
public class Entwickler extends Mitarbeiter {

  @Override
  public double berechneGehalt() {
    return 3500.0 + 500.0; // Grundgehalt + Ueberstundenbonus
  }
}

// Unterklasse Manager
public class Manager extends Mitarbeiter {

  @Override
  public double berechneGehalt() {
    return 4000.0 + 2000.0; // Grundgehalt + Provision
  }
}

Das `@Override` ist eine Annotation. Sie ist ein Hinweis an den Compiler: "Ich will hier eine Methode der Oberklasse überschreiben". Wenn du dich beim Methodennamen vertipst, bricht der Kompilierprozess ab. Das verhindert Fehler, bevor das Programm überhaupt startet.

Wie funktioniert Java Polymorphie im Code?

Jetzt kombinieren wir alles. Du siehst hier, wie eine einzige Variable vom Typ `Mitarbeiter` unterschiedliche Gehälter berechnet, je nachdem, welches Objekt darin gespeichert ist.

public class Gehaltsabrechnung {

  public static void main(String[] args) {
    // Polymorphe Zuweisungen
    Mitarbeiter m1 = new Mitarbeiter();
    Mitarbeiter m2 = new Entwickler();
    Mitarbeiter m3 = new Manager();

    // Drei Mal derselbe Methodenaufruf, aber drei verschiedene Ergebnisse
    System.out.println("Mitarbeiter: " + m1.berechneGehalt());
    // Ausgabe: 3000.0

    System.out.println("Entwickler: " + m2.berechneGehalt());
    // Ausgabe: 4000.0

    System.out.println("Manager: " + m3.berechneGehalt());
    // Ausgabe: 6000.0
  }
}

Siehst du den Trick? Obwohl `m2` und `m3` als Typ `Mitarbeiter` deklariert sind, rufen sie ihre eigenen, überschriebenen Methoden auf. Java schaut zur Laufzeit auf das "echte" Objekt im Speicher (nicht nur auf den Karton, in dem es steckt).

Das wird besonders mächtig, wenn du Listen verwendest. So kannst du hunderte verschiedener Mitarbeiter mit ein paar Zeilen Code abarbeiten:

import java.util.ArrayList;

public class GehaltsabrechnungListe {

  public static void main(String[] args) {
    ArrayList<Mitarbeiter> team = new ArrayList<>();
    team.add(new Mitarbeiter());
    team.add(new Entwickler());
    team.add(new Manager());

    // Eine Schleife fuer alle Typen
    for (Mitarbeiter m : team) {
      System.out.println("Gehalt: " + m.berechneGehalt());
    }
  }
}

Ohne Java Polymorphie müsstest du hier mühsam prüfen, ob das Objekt gerade ein Manager oder Entwickler ist (`instanceof`). Das macht den Code unübersichtlich und schwerer zu warten.

Wann nutzt man Polymorphie am besten?

Du solltest Polymorphie immer dann nutzen, wenn du Code schreiben willst, der für verschiedene Objekttypen allgemein gültig ist und zukunftssicher sein soll.

Typische Szenarien in der Praxis sind:

• Collections verarbeiten: Du iterierst über eine Liste von `Tiere`-Objekten und rufst `macheGeraeusch()` auf. Jedes Tier reagiert anders (Hund bellt, Katze miaut), dein Schleifen-Code bleibt aber identisch.

• Frameworks nutzen: Große Frameworks wie Spring oder JavaFX basieren auf Polymorphie. Du überschreibst Methoden, um das Verhalten des Frameworks anzupassen, ohne den Framework-Code selbst ändern zu müssen.

• Erweiterbarkeit (Open-Closed Principle): Du kannst später neue Unterklassen (z. B. `Praktikant`) hinzufügen, ohne deine bestehende Gehaltsabrechnung auch nur ein einziges Mal ändern zu müssen.

Welche Fehler sollte man bei Java Polymorphie vermeiden?

Auch wenn Polymorphie toll ist, gibt es Stolpersteine. Hier sind die drei häufigsten Fehler, die du als Einsteiger machen kannst.

Fehler 1: Statische Methoden überschreiben

Statische Methoden (mit `static`) gehören zur Klasse, nicht zum Objekt. Sie werden nicht polymorph aufgelöst.

public class Tier {
  public static void beschreibe() {
    System.out.println("Ich bin ein Tier");
  }
}

public class Ente extends Tier {
  public static void beschreibe() {
    System.out.println("Ich bin eine Ente");
  }
}

// Was passiert?
Tier t = new Ente();
t.beschreibe(); // Ausgabe: "Ich bin ein Tier" (!)

Hier entscheidet der Compiler den Aufruf anhand des Variablentyps (`Tier`), nicht des Objekts (`Ente`). Das nennt man Method Hiding, kein Overriding.

Fehler 2: Private Methoden überschreiben wollen

Private Methoden sind nur in der eigenen Klasse sichtbar. Unterklassen können sie nicht sehen und daher auch nicht überschreiben.

public class Basis {

  private void geheim() {
    System.out.println("Basis");
  }
}

public class Kind extends Basis {

  // Das ist eine NEUE Methode, keine Ueberschreibung!
  private void geheim() {
    System.out.println("Kind");
  }
}

Wenn du `geheim()` in `Kind` aufrufst, wird die Methode der Klasse `Basis` nicht berührt.

Fehler 3: Der Referenztyp bestimmt, was du sehen darfst

Das ist ein wichtiger Punkt für Verständnis. Selbst wenn das Objekt ein `Entwickler` ist - wenn die Variable als `Mitarbeiter` deklariert ist, kannst du nur Methoden aufrufen, die `Mitarbeiter` kennt.

Mitarbeiter m = new Entwickler();

m.berechneGehalt(); // OK - Mitarbeiter kennt diese Methode
// m.programmieren(); // FEHLER - Mitarbeiter kennt programmieren() nicht

Java weiß zur Laufzeit, dass da ein Entwickler ist, aber zur Übersetzungszeit (Compile-Time) prüft es nur den Typ der Variable (`Mitarbeiter`). Wenn du Methoden der Unterklasse nutzen willst, musst du einen Cast (Typumwandlung) machen: `((Entwickler) m).programmieren();`.

FAQ: Häufige Fragen zu Java Polymorphie

Kann ich Polymorphie ohne Vererbung nutzen?

Nein, Runtime-Polymorphie benötigt zwingend Vererbung oder die Implementierung von Interfaces. Compile-Time-Polymorphie (Overloading) hingegen funktioniert innerhalb einer einzigen Klasse ohne Vererbung.

Was ist der Unterschied zwischen Overloading und Overriding?

Overloading = Überladen. Du erstellst mehrere Methoden mit demselben Namen, aber unterschiedlichen Parametern in derselben Klasse. Overriding = Überschreiben. Eine Unterklasse ersetzt eine Methode der Oberklasse mit exakt derselben Signatur (gleicher Name, gleiche Parameter).

Warum sollte ich immer @Override schreiben?

Die Annotation `@Override` hilft dir, Fehler zu vermeiden. Der Compiler prüft dann, ob du wirklich eine Methode der Oberklasse überschreibst. Wenn du dich beim Methodennamen vertippst (z. B. `berechneGealt` statt `berechneGehalt`), bricht der Build sofort mit einer Fehlermeldung ab. Ohne `@Override` würde das Programm stillschweigend eine neue, leere Methode erstellen, was zu schweren Bugs führt.

Gilt Polymorphie auch für Attribute (Variablen)?

Nein. Attribute werden in Java nicht polymorph aufgelöst. Wenn du eine Variable `gehalt` sowohl in der Ober- als auch in der Unterklasse hast, entscheidet der Typ der Referenz (Variable), welchen Wert du liest - nicht der tatsächliche Objekttyp.

Was hat Polymorphie mit Interfaces zu tun?

Interfaces sind extrem wichtig für Polymorphie. Du definierst in einem Interface nur den "Vertrag" (die Methode), und verschiedene völlig unterschiedliche Klassen können diesen Vertrag erfüllen. So kannst du z. B. `Auto`, `Fahrrad` und `Roller` alle als das Interface `Fahrzeug` behandeln und die Methode `bewege()` aufrufen.

Fazit

Java Polymorphie ist kein trockenes Theoriewissen, sondern ein Werkzeug, das dir im Alltag als Entwickler das Leben enorm erleichtert. Ob du eine Gehaltsabrechnung baust, ein Framework nutzt oder sauberen Code schreiben willst - ohne Polymorphie würdest du in endlosen `if-else`- und `instanceof`-Ketten ertrinken.

Die wichtigsten Punkte im Schnelldurchlauf: Runtime-Polymorphie braucht Vererbung. Der Referenztyp bestimmt, welche Methoden du aufrufen kannst. Das tatsächliche Objekt bestimmt, was im Code passiert. Und vergiss nie das `@Override`!

Wenn du bei Vererbung, Polymorphie oder anderen Java-Themen feststeckst - egal ob in der Ausbildung, im Studium oder im Berufseinstieg - bei study-it.education bekommst du individuelle Online-Nachhilfe von erfahrenen Entwicklern. Wir holen dich genau da ab, wo du stehst.