Java super Keyword erklärt: So greifst du auf die Elternklasse zu

Stell dir vor, du baust ein Java-Projekt für deine Umschulung oder dein erstes Berufsprojekt. Du hast eine Basisklasse `Fahrzeug` und leitest davon `Elektroauto` ab. Jetzt willst du im Konstruktor des Elektroautos die Initialisierung aus `Fahrzeug` nutzen - aber wie kommst du an den Code der Elternklasse? Genau hier kommt das Java super Keyword ins Spiel. Es ist dein Verweis auf die direkte Elternklasse (auch Superklasse genannt) und funktioniert ähnlich wie das Java this Keyword, nur dass es nicht auf das aktuelle Objekt, sondern auf den vererbten Teil zeigt.

Was ist das Java super Keyword?

Das super Keyword in Java ist ein Verweis auf die direkte Elternklasse einer Klasse. Mit `super` greifst du auf Methoden, Variablen und Konstruktoren der Superklasse zu - besonders wichtig, wenn du in der Kindklasse gleichnamige Elemente überschreibst.

Java nutzt Vererbung (Inheritance), um Code wiederzuverwenden. Eine Kindklasse erbt dabei Eigenschaften und Verhalten von einer Elternklasse. Das super Keyword ist die Brücke zwischen beiden. Die offizielle Oracle-Dokumentation beschreibt es präzise.

Merke: `super` ist kein separates Objekt. Es ist ein Referenz-Keyword, das auf den geerbten Teil des aktuellen Objekts zeigt.

Wann brauchst du das Java super Keyword?

Das super Keyword kommt in drei typischen Situationen zum Einsatz. Welche das sind und wie sie sich unterscheiden, zeigt diese Übersicht:

Kernantwort: Du brauchst `super` immer dann, wenn du in einer Kindklasse auf die Originalversion eines Konstruktors, einer Methode oder einer Variablen der Elternklasse zugreifen willst.

Wie rufst du mit super den Elternkonstruktor auf?

Beim Erstellen einer Kindklasse ruft Java automatisch den Standardkonstruktor (ohne Parameter) der Elternklasse auf. Das passiert durch einen impliziten `super()`-Aufruf, den der Compiler einfügt. Problem: Wenn die Elternklasse keinen Standardkonstruktor hat, sondern nur einen parametrisierten, musst du `super(parameter)` explizit als erste Anweisung schreiben.

Warum? Weil Java sonst versucht, den nicht existierenden Standardkonstruktor aufzurufen - und das führt zu einem Compiler-Fehler.

class Fahrzeug {

  String marke;

  Fahrzeug(String marke) {
    this.marke = marke;
  }
}

class Elektroauto extends Fahrzeug {

  int reichweite;

  Elektroauto(String marke, int reichweite) {
    super(marke); // Muss erste Anweisung sein!
    this.reichweite = reichweite;
  }
}

Wichtig: Der `super()`-Aufruf muss immer die erste Anweisung in einem Konstruktor sein. Setzt du Code davor, kompiliert das Programm nicht.

Wie erweiterst du mit super eine überschriebene Methode?

Wenn du in deiner Kindklasse eine Methode aus der Elternklasse überschreibst, verdeckt die neue Methode die alte. Die Eltern-Methode ist damit nicht weg - du kommst nur nicht mehr direkt ran. Mit `super.methodenName()` rufst du die Originalversion auf.

Stell dir vor, du willst das Verhalten der Elternklasse erweitern, nicht komplett ersetzen. Das ist ein extrem häufiger Anwendungsfall in der Praxis.

class Tier {

  void macheGeraeusch() {
    System.out.println("Das Tier macht ein Geraeusch");
  }
}

class Hund extends Tier {

  @Override
  void macheGeraeusch() {
    super.macheGeraeusch(); // Ruft die Methode aus Tier auf
    System.out.println("Der Hund bellt: Wuff!");
  }
}

// Ausgabe bei new Hund().macheGeraeusch():
// Das Tier macht ein Geraeusch
// Der Hund bellt: Wuff!

Ohne den `super`-Aufruf würdest du das Verhalten der Elternklasse komplett verlieren. Mit `super` baust du darauf auf - das ist das Kernprinzip der Vererbung in Java.

Best Practice: Nutze `super.methode()`, wenn du vorhandene Logik erhalten und ergänzen willst, statt sie neu zu schreiben.

Wie greifst du mit super auf verdeckte Variablen zu?

Dieser Fall ist seltener, kommt aber vor. Wenn Eltern- und Kindklasse ein Attribut mit dem gleichen Namen haben, spricht man von Shadowing (dt. Beschattung). Die Variable der Kindklasse überschattet die der Elternklasse. Mit `super.variablenName` greifst du auf das Attribut der Elternklasse zu.

class Vater {

  String nachname = "Mueller";
}

class Sohn extends Vater {

  String nachname = "Schmidt"; // Beschattet Vater.nachname

  void zeigeNamen() {
    System.out.println("Eigener: " + this.nachname); // Schmidt
    System.out.println("Vater: " + super.nachname); // Mueller
  }
}

Tipp: Attribut-Shadowing vermeidest du besser durch saubere Namenskonventionen. Nutze `super` für Variablen nur, wenn du bestehenden Code nicht umbauen kannst.

Praxisbeispiel: Ein vollständiges Vererbungs-Szenario

Wir bauen eine kleine Klassenhierarchie für ein Projektmanagement-System. Du hast eine Basisklasse `Mitarbeiter` und leitest davon `Entwickler` ab. Das Beispiel zeigt alle drei super-Anwendungen in einem zusammenhängenden Kontext.

class Mitarbeiter {

  String name;
  int grundgehalt;

  // Konstruktor mit Pflicht-Parameter
  Mitarbeiter(String name, int grundgehalt) {
    this.name = name;
    this.grundgehalt = grundgehalt;
  }

  void zeigeInfo() {
    System.out.println("Mitarbeiter: " + name);
    System.out.println("Grundgehalt: " + grundgehalt + " EUR");
  }

  int berechneJahresgehalt() {
    return grundgehalt * 12;
  }
}

class Entwickler extends Mitarbeiter {

  int bonus;
  String programmiersprache;
  // Eigene Variable mit gleichem Namen wie in Elternklasse
  int grundgehalt = 60000; // Beschattet Mitarbeiter.grundgehalt

  Entwickler(String name, int grundgehalt, int bonus, String sprache) {
    super(name, grundgehalt); // 1. Konstruktor der Elternklasse aufrufen
    this.bonus = bonus;
    this.programmiersprache = sprache;
  }

  @Override
  void zeigeInfo() {
    super.zeigeInfo(); // 2. Methode der Elternklasse aufrufen
    System.out.println("Sprache: " + programmiersprache);
    System.out.println("Bonus: " + bonus + " EUR");
  }

  @Override
  int berechneJahresgehalt() {
    int basis = super.berechneJahresgehalt(); // 3. Eltern-Methode nutzen
    return basis + bonus;
  }

  void zeigeGehaltUnterschied() {
    System.out.println("Entwickler-Grundgehalt: " + this.grundgehalt);
    System.out.println("Mitarbeiter-Grundgehalt: " + super.grundgehalt);
  }
}

public class Main {

  public static void main(String[] args) {
    Entwickler dev = new Entwickler("Anna", 55000, 5000, "Java");
    dev.zeigeInfo();
    System.out.println("Jahresgehalt: " + dev.berechneJahresgehalt() + " EUR");
    dev.zeigeGehaltUnterschied();
  }
}

Ausgabe:

Mitarbeiter: Anna
Grundgehalt: 55000 EUR
Sprache: Java
Bonus: 5000 EUR
Jahresgehalt: 665000 EUR
Entwickler-Grundgehalt: 60000
Mitarbeiter-Grundgehalt: 55000

Häufige Fehler: Was Azubis und Studenten falsch machen

Fehler 1: super() nicht als erste Anweisung

// FALSCH
Entwickler(String name) {
  this.bonus = 5000;
  super(name); // Compiler-Fehler!
}

// RICHTIG
Entwickler(String name) {
  super(name);        // Erste Anweisung
  this.bonus = 5000;  // Danach eigene Initialisierung
}

Der Compiler meldet: *`call to super must be first statement in constructor`*. Das gilt auch, wenn du `this()` (Konstruktor-Verkettung innerhalb der gleichen Klasse) nutzt - `super()` und `this()` schließen sich gegenseitig aus.

Fehler 2: super für private Methoden nutzen

class Basis {

  private void geheimMethode() {
    System.out.println("Geheim");
  }
}

class Kind extends Basis {

  void teste() {
    super.geheimMethode(); // Compiler-Fehler!
  }
}

Private Methoden werden nicht vererbt und sind in der Kindklasse unsichtbar. `super` hilft hier nicht, weil `private` bedeutet: Nur innerhalb der gleichen Klasse sichtbar. Mehr zum Thema Sichtbarkeit und Kapselung findest du im verlinkten Beitrag.

Fehler 3: super geht nur EINE Ebene nach oben

`super` verweist immer auf die direkte Elternklasse - nicht auf die Großelternklasse. Wenn du `A -> B -> C` verertest, kann `C` mit `super` nur auf `B` zugreifen, nicht direkt auf `A`. Es gibt in Java kein `super.super`. Weitere Details dazu findest du auch bei W3Schools Java Super.

Übungstipp: Baue deine eigene Klassenhierarchie

Nimm dir 15 Minuten Zeit und baue folgende Hierarchie:

1. Erstelle eine Klasse `Geraet` mit einem Konstruktor, der einen `String hersteller` erwartet

2. Leite `Smartphone` ab und füge ein Attribut `String betriebssystem` hinzu

3. Überschreibe eine Methode `starte()` - rufe darin `super.starte()` auf und ergänze eigene Logik

4. Erzeuge in einer `main`-Methode ein Smartphone und teste alle Methoden

Das Beispiel ist typisch für IHK-Abschlussprüfungen im Fachbereich Anwendungsentwicklung oder für OOP-Klausuren im Studium. Wenn du dabei festhängst, hilft dir unsere Java-Nachhilfe weiter.

FAQ: Häufige Fragen zum Java super Keyword

Kann ich super in einer statischen Methode verwenden?

Nein. Statische Methoden gehören zur Klasse, nicht zu einem Objekt. Da `super` eine Instanzreferenz ist, funktioniert es nur in Instanzmethoden und Konstruktoren. Mehr dazu im Beitrag zum Java static Keyword.

Was ist der Unterschied zwischen super und this?

`this` verweist auf das aktuelle Objekt selbst, `super` auf den geerbten Teil der Elternklasse. `this` nutzt du für Selbstreferenz und Konstruktorverkettung, `super` für den Elternklassen-Zugriff. Details zu `this` findest du im Beitrag Java this Keyword einfach erklärt.

Was passiert, wenn ich super() nicht schreibe?

Wenn die Elternklasse einen Standardkonstruktor hat, fügt der Compiler automatisch `super()` ein. Hat sie keinen, musst du `super(parameter)` explizit aufrufen - sonst kompiliert der Code nicht.

Kann ich super.super schreiben, um auf die Großelternklasse zuzugreifen?

Nein, das ist in Java nicht erlaubt. `super` geht immer nur eine Ebene nach oben. Der Versuch führt zu einem Compiler-Fehler.

Gilt super auch für Interfaces?

Seit Java 8 kannst du mit `InterfaceName.super.methodenName()` auf eine Default-Methode eines Interfaces zugreifen, wenn eine Klasse mehrere Interfaces implementiert. Das klassische `super` funktioniert aber nur für Klassenvererbung. Mehr dazu im Vergleich abstrakte Klassen vs. Interfaces.

Fazit: super ist dein Werkzeug für saubere Vererbung

Das Java super Keyword gehört zu den Grundlagen der objektorientierten Programmierung, die du als Fachinformatiker, IT-Student oder Berufseinsteiger beherrschen musst. Drei Dinge solltest du mitnehmen: `super()` ruft den Elternkonstruktor auf (immer als erste Anweisung), `super.methode()` greift auf überschriebene Methoden zu, und `super.variable` löst Attribut-Shadowing auf.

Die größten Stolperfallen sind die Pflicht zur ersten Anweisung im Konstruktor und die Tatsache, dass `super` nicht bei `private`-Methoden funktioniert. Wenn du diese Regeln verinnerlichst, kannst du Vererbungshierarchien sauber aufbauen und vorhandenen Code wiederverwenden.

Brauchst du Hilfe bei Java-Themen wie Vererbung, Polymorphie oder dem final Keyword? Unsere Nachhilfelehrer bei study-it.education unterstützen dich - egal ob du dich auf die IHK-Prüfung vorbereitest, eine Studienarbeit schreiben musst oder in deinem ersten Job als Junior Developer Unterstützung brauchst. Schau vorbei und vereinbare ein kostenloses Erstgespräch.