Java super-Schlüsselwort erklärt: Konstruktoren, Methoden und Felder (mit Beispielen)

1. Beziehung zwischen Vererbung und super

Um das super-Schlüsselwort in Java zu verstehen, sollten Sie zuerst Vererbung verstehen.
super ist nichts, das man isoliert auswendig lernt – seine Bedeutung wird klar, sobald man sieht, wie eine Kindklasse und eine Elternklasse zusammenarbeiten.

In diesem Abschnitt lernen Sie, was Vererbung ist und warum super überhaupt existiert, mit anfängerfreundlichen Erklärungen und einfachen Code-Beispielen.

1.1 Was ist Vererbung in Java? (extends Grundlagen)

In Java ermöglicht Vererbung die Erstellung einer neuen Klasse basierend auf einer bestehenden Klasse.

• Elternklasse (Superklasse) : die Basisklasse
• Kindklasse (Unterklasse) : die Klasse, die von der Elternklasse erbt

Wenn eine Kindklasse eine Elternklasse erweitert, kann sie die Felder und Methoden der Elternklasse wiederverwenden, ohne sie neu zu schreiben.

Grundlegende Vererbungssyntax (extends)

class Parent {
    void hello() {
        System.out.println("Hello from Parent");
    }
}

class Child extends Parent {
}

Hier erbt Child die hello()-Methode von Parent.

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.hello(); // calling a method inherited from Parent
    }
}

Ausgabe:

Hello from Parent

Also kann Child hello() aufrufen, obwohl es nicht definiert ist, weil es geerbt wurde.

1.2 Warum brauchen wir super?

An diesem Punkt könnten Sie denken:

„Wenn die Kindklasse bereits alles von der Elternklasse erbt, warum brauchen wir dann super überhaupt?“

In vielen Fällen müssen Sie super nicht explizit schreiben.
Allerdings wird super notwendig, wenn Sie die Elternversion von etwas klar zugreifen möchten.

Häufige Situationen umfassen:

• Die Kindklasse überschreibt eine Methode, aber Sie möchten immer noch die Elternversion aufrufen
• Die Kindklasse und die Elternklasse haben Felder mit demselben Namen
• Sie müssen einen spezifischen Elternkonstruktor mit Argumenten aufrufen

Kurz gesagt:

super wird verwendet, wenn Sie explizit auf die Elternklasse-Seite verweisen möchten.

1.3 Überschreiben und super (Beibehaltung des Elternverhaltens)

Einer der häufigsten Gründe für die Verwendung von super ist das Überschreiben von Methoden.

Überschreiben bedeutet, dass die Kindklasse ihre eigene Version einer Methode bereitstellt, die bereits in der Elternklasse existiert.

Beispiel: Überschreiben einer Methode

class Parent {
    void greet() {
        System.out.println("Parent: Hello!");
    }
}

class Child extends Parent {
    @Override
    void greet() {
        System.out.println("Child: Hi!");
    }
}

Nun, wenn Sie greet() auf einem Child-Objekt aufrufen:

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.greet();
    }
}

Ausgabe:

Child: Hi!

Die Kindversion wird ausgeführt, weil das Überschreiben der Kindklasse Vorrang gibt.

Aufruf der Elternversion mit super.greet()

Manchmal möchten Sie das Elternverhalten nicht vollständig ersetzen – Sie möchten nur zusätzliche Logik hinzufügen.

Hier ist super.method() nützlich:

class Parent {
    void greet() {
        System.out.println("Parent: Hello!");
    }
}

class Child extends Parent {
    @Override
    void greet() {
        super.greet(); // call parent version
        System.out.println("Child: Hi!");
    }
}

Ausgabe:

Parent: Hello!
Child: Hi!

Dies ist ein sehr praktisches Muster:

• Elternklasse behandelt gemeinsames Verhalten
• Kindklasse fügt benutzerdefiniertes Verhalten hinzu

1.4 Wenn Eltern und Kind denselben Feldnamen haben

Eine weitere Situation, in der super wichtig ist, ist, wenn eine Eltern- und Kindklasse Felder mit demselben Namen haben.

Beispiel:

class Parent {
    int value = 100;
}

class Child extends Parent {
    int value = 200;

    void printValue() {
        System.out.println(value);
    }
}

Hier bezieht sich value auf das Feld der Kindklasse, daher wird die Ausgabe sein:

200

Wenn Sie auf das übergeordnete Feld zugreifen möchten, verwenden Sie super.value:

class Child extends Parent {
    int value = 200;

    void printValue() {
        System.out.println(value);       // child value
        System.out.println(super.value); // parent value
    }
}

Ausgabe:

200
100

Wichtige Erkenntnis:

• value → Feld der Kindklasse
• super.value → Feld der Elternklasse

1.5 Was super wirklich bedeutet (einfache Definition)

Jetzt können Sie super so zusammenfassen:

super ist ein Schlüsselwort, das Ihnen ermöglicht, explizit die Version der Elternklasse von Feldern, Methoden und Konstruktoren zuzugreifen.

Wenn Sie sich nur eine Zeile merken, dann merken Sie sich diese:

super bedeutet „die Version der Elternklasse verwenden“.

Im nächsten Abschnitt lernen Sie die 3 wichtigsten Möglichkeiten, super zu verwenden, mit klaren Beispielen für jede.

2. Wie man super verwendet (3 Kernmuster)

Jetzt, da Sie verstehen, was super bedeutet, konzentrieren wir uns darauf, wie es tatsächlich in Java verwendet wird.

Im realen Code erscheint super in drei Hauptmustern:

1. Aufruf eines Elternkonstruktors ( super() / super(args...) )
2. Aufruf einer Elternmethode ( super.method() )
3. Zugriff auf ein Elternfeld ( super.field )

Sobald Sie diese drei kennen, wird super sehr leicht zu erkennen und korrekt zu verwenden sein.

2.1 Aufruf eines Elternkonstruktors (super() / super(args...))

2.1.1 Kurze Auffrischung: Was ist ein Konstruktor?

Ein Konstruktor ist eine spezielle Methode, die ausgeführt wird, wenn Sie ein Objekt erstellen.

class Person {
    Person() {
        System.out.println("Person constructor");
    }
}

Konstruktoren werden zur Initialisierung verwendet, z. B. zum Einrichten von Feldern.

2.1.2 Bei Vererbung wird zuerst der Elternkonstruktor ausgeführt

Bei Java‑Vererbung beginnt das Erzeugen eines Kindobjekts immer damit, zuerst den Elternteil zu initialisieren.

Das bedeutet:

Elternkonstruktor → Kindkonstruktor

Beispiel:

class Parent {
    Parent() {
        System.out.println("Parent constructor");
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child constructor");
    }
}

public class Main {
    public static void main(String[] args) {
        new Child();
    }
}

Ausgabe:

Parent constructor
Child constructor

Obwohl wir super() nicht geschrieben haben, wurde der Elternkonstruktor trotzdem ausgeführt.

2.1.3 super() wird automatisch eingefügt (wenn möglich)

Wenn die Elternklasse einen konstruktor ohne Argumente hat, fügt Java diese Zeile automatisch am Anfang des Kindkonstruktors ein:

super();

Damit sind diese beiden Konstruktoren im Wesentlichen gleich:

Child() {
    System.out.println("Child constructor");
}

Child() {
    super(); // implicitly inserted by the compiler
    System.out.println("Child constructor");
}

2.1.4 Wenn die Elternklasse nur einen parametrisierten Konstruktor hat

Dies ist einer der häufigsten Anfängerfehler.

Wenn die Elternklasse keinen konstruktor ohne Argumente hat, kann Java super() nicht automatisch einfügen.

Beispiel (dies führt zu einem Kompilierfehler):

class Parent {
    Parent(int x) {
        System.out.println("Parent: " + x);
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child created");
    }
}

Warum es fehlschlägt:

• Der Compiler versucht, super(); einzufügen
• Aber Parent() existiert nicht

✅ Lösung: den korrekten Elternkonstruktor explizit aufrufen

class Child extends Parent {
    Child() {
        super(10);
        System.out.println("Child created");
    }
}

Ausgabe:

Parent: 10
Child created

2.1.5 super(...) muss die erste Zeile im Konstruktor sein

Java verlangt, dass super(...) die erste Anweisung in einem Konstruktor ist.

❌ Falsch:

Child() {
    System.out.println("Something first");
    super(10); // compile error
}

✅ Richtig:

Child() {
    super(10);
    System.out.println("Child logic");
}

Grund:

• Der Parent muss initialisiert werden, bevor das Kind seine eigene Logik sicher ausführen kann.

2.2 Aufruf einer Parent-Methode (super.method())

Ein weiterer sehr häufiger Anwendungsfall ist der Aufruf der Parent-Methode nach dem Überschreiben.

2.2.1 Grundbeispiel

class Parent {
    void show() {
        System.out.println("Parent show()");
    }
}

class Child extends Parent {
    @Override
    void show() {
        System.out.println("Child show()");
    }

    void test() {
        super.show(); // parent version
        show();       // child version
    }
}

public class Main {
    public static void main(String[] args) {
        new Child().test();
    }
}

Ausgabe:

Parent show()
Child show()

2.2.2 Wann ist das nützlich?

super.method() ist nützlich, wenn:

• Die Parent-Methode gemeinsame Logik enthält
• Die Child-Methode das Verhalten erweitern muss, anstatt es zu ersetzen
• Sie das Kopieren und Einfügen der Parent-Logik in das Child vermeiden möchten

Beispiel:

class Parent {
    void process() {
        System.out.println("Common processing");
    }
}

class Child extends Parent {
    @Override
    void process() {
        super.process();
        System.out.println("Child-specific processing");
    }
}

Dieses Muster hält Ihren Code sauber und wartbar.

2.3 Zugriff auf ein Parent-Feld (super.field)

Felder funktionieren ähnlich. Wenn sowohl Parent als auch Child ein Feld mit demselben Namen haben, verbirgt das Child-Feld das Parent-Feld.

Beispiel:

class Parent {
    int value = 100;
}

class Child extends Parent {
    int value = 200;

    void print() {
        System.out.println(value);       // child field
        System.out.println(super.value); // parent field
    }
}

public class Main {
    public static void main(String[] args) {
        new Child().print();
    }
}

Ausgabe:

200
100

2.3.1 Sollten Sie das in realen Projekten tun?

Normalerweise ist es keine gute Idee, denselben Feldnamen in Parent und Child zu verwenden, da es Leser verwirren kann.

Es kann jedoch vorkommen, wenn:

• Sie Legacy-Code warten
• Sie gezwungen sind, ein bestehendes Parent-Klassendesign anzupassen
• Sie Parent- vs. Child-Werte klar unterscheiden müssen

In diesen Fällen ist super.field das richtige Werkzeug.

2.4 Zusammenfassung der 3 Muster

Sie können sich an super so erinnern:

• super() / super(args...) → Parent-Konstruktor aufrufen
• super.method() → Parent-Methode aufrufen
• super.field → Parent-Feld zugreifen

Im nächsten Abschnitt gehen wir tiefer mit praktischen Code-Beispielen, damit Sie klar sehen können, wie sich diese Muster bei der Ausführung verhalten.

3. Praktische Beispiele, um super zu meistern

Zu diesem Zeitpunkt kennen Sie bereits die drei Kernweisen, super zu verwenden.
Nun lassen Sie uns dieses Wissen verfestigen, indem wir praktische Beispiele durchgehen.

Dieser Abschnitt konzentriert sich auf:

• Ausführungsreihenfolge
• Was aufgerufen wird und warum
• Wie super das Verhalten in realem Code ändert

3.1 Beispiel 1: Konstruktor-Aufrufreihenfolge (Parent → Child)

Die wichtigste Regel, die Sie sich merken sollten:

Beim Erstellen eines Child-Objekts initialisiert Java immer zuerst den Parent-Teil.

class Parent {
    Parent() {
        System.out.println("Parent constructor");
    }
}

class Child extends Parent {
    Child() {
        super(); // optional here, but allowed
        System.out.println("Child constructor");
    }
}

public class Main {
    public static void main(String[] args) {
        new Child();
    }
}

Ausgabe:

Parent constructor
Child constructor

Schlüsselpunkt:
Selbst wenn Sie super() entfernen, ist das Ergebnis dasselbe (solange der Parent einen Parameterlosen Konstruktor hat).

3.2 Beispiel 2: Parent hat nur einen parametrisierten Konstruktor

Wenn die Parent-Klasse keinen Parameterlosen Konstruktor hat, muss das Child explizit den richtigen aufrufen.

class Parent {
    Parent(String name) {
        System.out.println("Parent: " + name);
    }
}

class Child extends Parent {
    Child() {
        super("Taro");
        System.out.println("Child created");
    }
}

public class Main {
    public static void main(String[] args) {
        new Child();
    }
}

Output:

Parent: Taro
Child created

Key point:
If you forget super("Taro"), Java tries to insert super() automatically and fails.

3.3 Example 3: Calling a parent method after overriding (super.method())

This is one of the most useful patterns in real projects.

class Parent {
    void greet() {
        System.out.println("Hello from Parent");
    }
}

class Child extends Parent {
    @Override
    void greet() {
        super.greet(); // call parent behavior
        System.out.println("Hello from Child");
    }
}

public class Main {
    public static void main(String[] args) {
        new Child().greet();
    }
}

Output:

Hello from Parent
Hello from Child

Key point:
You can extend parent behavior without rewriting it.

3.4 Example 4: Accessing a hidden parent field (super.field)

If parent and child both define a field with the same name, the child version hides the parent version.

class Parent {
    int value = 100;
}

class Child extends Parent {
    int value = 200;

    void printValues() {
        System.out.println("Child value: " + value);
        System.out.println("Parent value: " + super.value);
    }
}

public class Main {
    public static void main(String[] args) {
        new Child().printValues();
    }
}

Output:

Child value: 200
Parent value: 100

Key point:

• value refers to the child’s field
• super.value refers to the parent’s field

3.5 Example 5: Calling both parent and child versions clearly

This is a great example to remove confusion.

class Parent {
    void show() {
        System.out.println("Parent show()");
    }
}

class Child extends Parent {
    @Override
    void show() {
        System.out.println("Child show()");
    }

    void test() {
        super.show(); // parent version
        this.show();  // child version (same as just calling show())
    }
}

public class Main {
    public static void main(String[] args) {
        new Child().test();
    }
}

Output:

Parent show()
Child show()

Key point:

• super.show() = parent
• this.show() = child

3.6 A realistic example: shared logic in the parent class

In real applications, parent classes often contain common logic such as logging, validation, or setup steps.

class BaseService {
    void execute() {
        System.out.println("[LOG] Start execution");
    }
}

class UserService extends BaseService {
    @Override
    void execute() {
        super.execute(); // reuse shared behavior
        System.out.println("UserService logic running...");
    }
}

public class Main {
    public static void main(String[] args) {
        new UserService().execute();
    }
}

Output:

[LOG] Start execution
UserService logic running...

Why this is useful:

• You avoid duplicating common behavior
• The child focuses only on what’s unique
• Your code becomes easier to maintain

3.7 Section summary

From these examples, you should remember:

• Parent constructors run before child constructors
• super(args...) is required if the parent has no no-arg constructor
• super.method() is perfect for reusing and extending behavior
• super.field helps when parent and child fields share the same name

Next, we’ll clarify one of the most confusing topics for beginners:

What’s the difference between this and super?

4. Difference Between this and super

When learning Java’s super, you will almost always see this at the same time.
Both are reference keywords, so it’s easy for beginners to mix them up.

In this section, you’ll learn:

• Was this bedeutet
• Was super bedeutet
• Wie man sie korrekt mit Feldern, Methoden und Konstruktoren verwendet

4.1 this bezieht sich auf das aktuelle Objekt (die Kindinstanz)

this bedeutet:

„die aktuelle Objektinstanz“

Es wird am häufigsten verwendet, wenn ein Feldname und ein Konstruktorparameter denselben Namen haben.

class User {
    String name;

    User(String name) {
        this.name = name; // field = parameter
    }
}

Hier:

• name (rechte Seite) ist der Konstruktorparameter
• this.name (linke Seite) ist das Instanzfeld

So hilft this, Verwirrung zu vermeiden.

4.2 super bezieht sich auf die Elternklasse

super bezieht sich auf den Teil der Elternklasse (Superklasse) des aktuellen Objekts.

Es bedeutet:

„die Version der Elternklasse verwenden“

Man verwendet es hauptsächlich, wenn man auf Elternmitglieder zugreifen möchte, die verborgen oder überschrieben sind.

4.3 Die einfachste Art, den Unterschied zu merken

Eine anfängerfreundliche Merkhilfe:

• this → die Kindklassen‑Seite
• super → die Elternklassen‑Seite

Sie sind nicht zwei verschiedene Objekte.
Sie sind zwei verschiedene „Ansichten“ desselben Objekts.

4.4 Verwendung von this und super mit Feldern

Wenn sowohl die Eltern‑ als auch die Kindklasse ein Feld mit demselben Namen definieren, kann man eindeutig wählen, welches man möchte.

class Parent {
    int value = 100;
}

class Child extends Parent {
    int value = 200;

    void print() {
        System.out.println(this.value);  // child field
        System.out.println(super.value); // parent field
    }
}

public class Main {
    public static void main(String[] args) {
        new Child().print();
    }
}

Ausgabe:

200
100

Wichtiger Punkt:

• this.value = Kindfeld
• super.value = Elternfeld

Außerdem ist this in Java oft optional:

System.out.println(value);

ist dasselbe wie:

System.out.println(this.value);

4.5 Verwendung von this und super mit Methoden

Methoden sind der häufigste Bereich, in dem this vs super eine Rolle spielt – besonders beim Überschreiben.

class Parent {
    void show() {
        System.out.println("Parent show()");
    }
}

class Child extends Parent {
    @Override
    void show() {
        System.out.println("Child show()");
    }

    void test() {
        this.show();   // child method (same as show())
        super.show();  // parent method
    }
}

public class Main {
    public static void main(String[] args) {
        new Child().test();
    }
}

Ausgabe:

Child show()
Parent show()

Wichtiger Punkt:

• this.show() → Kind‑Version
• super.show() → Eltern‑Version

4.6 Konstruktoren: this() vs super()

Das ist einer der verwirrendsten Teile für Anfänger, aber er ist sehr wichtig.

• this() ruft einen anderen Konstruktor in derselben Klasse auf
• super() ruft einen Konstruktor in der Elternklasse auf

4.6.1 Beispiel für this() (Konstruktorverkettung innerhalb derselben Klasse)

class User {
    String name;
    int age;

    User() {
        this("NoName", 0); // call another constructor
    }

    User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Das ist nützlich, weil es das Wiederholen von Initialisierungslogik vermeidet.

4.6.2 Beispiel für super() (Aufruf des Elternkonstruktors)

class Parent {
    Parent() {
        System.out.println("Parent constructor");
    }
}

class Child extends Parent {
    Child() {
        super(); // initialize parent
        System.out.println("Child constructor");
    }
}

Ausgabe:

Parent constructor
Child constructor

4.7 Sie können this() und super() nicht zusammen verwenden

Viele Anfänger versuchen etwas wie das:

Child() {
    this(1);
    super(); // error
}

Das ist nicht erlaubt.

Grund:

• Sowohl this() als auch super() müssen die erste Zeile im Konstruktor sein
• Nur eines von beiden kann zuerst stehen

Daher muss man sich für eines entscheiden.

4.8 Wichtiger Hinweis: super erzeugt kein neues Objekt

.

super erzeugt kein separates Elternobjekt.

Stattdessen:

• this = aktuelles Objekt, betrachtet als Kind
• super = dasselbe Objekt, betrachtet als Elternteil

Deshalb sollte man super am besten als Referenz‑Schlüsselwort verstehen, nicht als Objekt‑Erzeuger.

4.9 Abschnittszusammenfassung

• this verweist auf das aktuelle Objekt (Kind‑Seite)
• super verweist auf die Eltern‑Klassen‑Seite
• this() ruft einen anderen Konstruktor derselben Klasse auf
• super() ruft einen Konstruktor der Elternklasse auf
• this() und super() können nicht zusammen verwendet werden

Als Nächstes behandeln wir häufige Fehler und Fehlermuster, damit Sie die typischen Anfänger‑Fallen vermeiden können.

5. Häufige Fehler und Fallstricke (Wie man Fehler vermeidet)

Das Java‑Schlüsselwort super ist mächtig, wird aber leicht missbraucht – besonders, wenn man noch die Vererbung und Konstruktoren lernt.

In diesem Abschnitt lernen Sie die häufigsten Fehler von Anfängern kennen und wie Sie sie schnell beheben.

5.1 super(...) an der falschen Stelle schreiben (Konstruktorregel)

Eine der wichtigsten Regeln:

super(...) muss die erste Anweisung innerhalb eines Konstruktors sein.

❌ Falsch (Kompilierungsfehler):

class Parent {
    Parent(int x) {}
}

class Child extends Parent {
    Child() {
        System.out.println("Do something first");
        super(10); // ERROR: must be first line
    }
}

✅ Richtig:

class Child extends Parent {
    Child() {
        super(10);
        System.out.println("Child logic");
    }
}

Warum?
Der Eltern‑Teil des Objekts muss initialisiert werden, bevor die Kind‑Logik ausgeführt wird.

5.2 Vergessen von super(args…), wenn die Elternklasse keinen parameterlosen Konstruktor hat

Hat die Elternklasse nur einen parametrisierten Konstruktor, kann Java nicht automatisch super() einfügen.

❌ Falsch:

class Parent {
    Parent(String name) {}
}

class Child extends Parent {
    Child() {
        // compiler tries to insert super() here -> ERROR
    }
}

✅ Richtig:

class Child extends Parent {
    Child() {
        super("Taro");
    }
}

Das ist ein sehr häufiger Kompilierungsfehler für Anfänger – prüfen Sie also immer die Konstruktoren der Elternklasse.

5.3 Versuch, sowohl this() als auch super() im selben Konstruktor zu verwenden

Anfänger denken oft:

„Ich möchte einen anderen Konstruktor UND den Eltern‑Konstruktor aufrufen.“

Java erlaubt das jedoch nicht.

❌ Falsch:

class Parent {
    Parent() {}
}

class Child extends Parent {
    Child() {
        this(1);
        super(); // ERROR
    }

    Child(int x) {}
}

Grund:

• this() und super() müssen beide die erste Zeile sein
• Es kann nur eines von beiden zuerst stehen

Daher müssen Sie Ihre Konstruktoren so entwerfen, dass nur eines davon direkt verwendet wird.

5.4 Versuch, super in einer statischen Methode zu benutzen

super ist an die aktuelle Objektinstanz gebunden und funktioniert daher nicht in statischen Methoden.

❌ Falsch (konzeptionell):

class Parent {
    void hello() {}
}

class Child extends Parent {
    static void test() {
        super.hello(); // ERROR
    }
}

Wichtiger Hinweis:

• Statische Methoden gehören zur Klasse, nicht zu einer Instanz
• super bezieht sich auf den Eltern‑Teil einer Instanz

Deshalb verhindert Java das.

5.5 Missverständnis, super würde ein „Eltern‑Objekt“ erzeugen

Manche Anfänger gehen davon aus:

„Durch super wird ein separates Eltern‑Objekt erstellt.“

Das stimmt nicht.

super erstellt kein neues Objekt.
Es greift lediglich auf die Eltern‑Klassen‑Seite desselben Objekts zu.

Stellen Sie sich das so vor:

• this = dasselbe Objekt, Kind‑Sicht
• super = dasselbe Objekt, Eltern‑Sicht

5.6 Zu häufiges Verwenden von super.field (Feldverstecken ist meist eine schlechte Idee)

Ja, super.field gibt es – aber in den meisten realen Projekten sollte man vermeiden, Eltern‑ und Kind‑Felder mit demselben Namen zu definieren.

Beispiel (verwirrender Entwurf):

class Parent {
    int value = 100;
}

class Child extends Parent {
    int value = 200; // hides parent field
}

Obwohl super.value funktioniert, macht dieses Design den Code schwerer lesbar und wartbar.

Bessere Praxis:

• Verwende unterschiedliche Feldnamen
• Halte Felder privat und stelle sie mit Methoden (Getters) zur Verfügung
• Vermeide das Verstecken von Feldern, es sei denn, es ist absolut notwendig

5.7 „Wenn ich super.method() aufrufe, läuft nur die Elternlogik“ (nicht immer)

Das ist etwas fortgeschrittener, aber nützlich zu wissen.

Wenn du super.method() aufrufst, rufst du definitiv die Elternmethode auf.
Allerdings, innerhalb dieser Elternmethode, wenn sie eine andere Methode aufruft, die das Kind überschreibt, kann die Kindversion ausgeführt werden.

Beispiel:

class Parent {
    void a() {
        b(); // calls b()
    }

    void b() {
        System.out.println("Parent b()");
    }
}

class Child extends Parent {
    @Override
    void b() {
        System.out.println("Child b()");
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        c.a();
    }
}

Ausgabe:

Child b()

Obwohl a() in der Elternklasse ist, ruft sie b() auf, und b() ist im Kind überschrieben.

Takeaway für Anfänger:
super.method() ruft die Elternversion dieser Methode auf, aber Methodenaufrufe innerhalb davon können immer noch Überschreibungsregeln verwenden.

5.8 Schnelle Checkliste (um Anfängerfehler zu vermeiden)

Bevor du super verwendest, überprüfe diese:

• Ist super(...) die erste Zeile im Konstruktor?
• Hat die Elternklasse einen Konstruktor ohne Argumente?
• Versucht du sowohl this() als auch super() zu verwenden?
• Verwenden Sie super innerhalb einer statischen Methode?
• Versteckst du Felder mit demselben Namen unnötig?

6. Schlussfolgerung (Wichtige Erkenntnisse)

In diesem Artikel hast du gelernt, was das super-Schlüsselwort in Java ist, warum es existiert und wie man es korrekt in echtem Code verwendet.

Lass uns alles mit den wichtigsten Punkten zusammenfassen, die du dir merken solltest.

6.1 Was bedeutet super in Java?

super ist ein Schlüsselwort, das dir erlaubt, explizit auf den Elternklassen (Superklasse)-Teil eines Objekts zuzugreifen.

Es wird hauptsächlich in der Vererbung (extends) verwendet, wenn du auf die Elternversion von verweisen möchtest:

• Konstruktoren
• Methoden
• Felder

In einfachen Worten:

super bedeutet „verwende die Elternklassenversion.“

6.2 Die 3 wichtigsten Wege, super zu verwenden

Du kannst super in diesen drei Mustern merken:

1) Rufe den Elternkonstruktor auf

• super()
• super(args...)

Das wird verwendet, wenn du die Elternklasse richtig initialisieren musst, besonders wenn die Elternklasse Argumente benötigt.

2) Rufe die Elternmethode auf

• super.method()

Das ist nützlich, wenn du eine Methode überschreibst, aber das Elternverhalten weiterhin wiederverwenden möchtest.

3) Greife auf das Elternfeld zu

• super.field

Das wird verwendet, wenn sowohl Eltern- als auch Kindklasse ein Feld mit demselben Namen haben und du klar auf das Elternfeld verweisen möchtest.

6.3 this vs super (der einfachste Weg, es zu verstehen)

Viele Anfänger verwechseln diese zwei Schlüsselwörter, aber der Unterschied ist einfach:

• this → das aktuelle Objekt (Sicht vom Kind aus)
• super → die Sicht vom Elternteil des gleichen Objekts

Sie repräsentieren nicht zwei verschiedene Objekte.

6.4 Die meisten Fehler passieren um Konstruktoren herum

Wenn du die häufigsten Fehler vermeiden möchtest, merke dir diese Regeln:

• super(...) muss die erste Zeile innerhalb eines Konstruktors sein
• Wenn die Elternklasse keinen Konstruktor ohne Argumente hat, musst du super(args...) schreiben
• Du kannst this() und super() nicht zusammen in demselben Konstruktor verwenden
• super funktioniert nicht in statischen Methoden

6.5 Abschließende Erkenntnis: super hilft dir, Elternlogik sicher wiederzuverwenden und zu erweitern

Die wahre Macht von super ist, dass es dir erlaubt:

• gemeinsame Logik in der Elternklasse zu behalten
• Verhalten in der Kindklasse zu erweitern
• Code-Kopieren zu vermeiden
• Vererbung sauberer und leichter zu warten zu machen

Wenn du dir eine Zeile aus diesem gesamten Artikel merken möchtest, merke dir diese:

super ist das Schlüsselwort, das du verwendest, wenn du die Elternklassenversion möchtest.

7. FAQ (Häufig gestellte Fragen)

Hier sind die häufigsten Fragen, die Anfänger stellen, wenn sie das super-Schlüsselwort in Java lernen.
Falls Sie sich bei bestimmten Teilen immer noch unsicher fühlen, sollte dieser Abschnitt die Dinge schnell klären.

7.1 Wann sollte ich super in Java verwenden?

Sie verwenden super typischerweise in diesen Situationen:

• Wenn Sie einen Elternkonstruktor aufrufen möchten ( super() / super(args...) )
• Wenn Sie eine Methode überschreiben, aber immer noch die Elternmethode aufrufen möchten ( super.method() )
• Wenn die Eltern- und Kindklasse denselben Feldnamen haben und Sie das Elternfeld möchten ( super.field )

Für Anfänger ist der häufigste und nützlichste Fall:

das Überschreiben einer Methode und das Aufrufen der Elternlogik mit super.method().

7.2 Was passiert, wenn ich super() nicht schreibe?

Wenn die Elternklasse einen Konstruktor ohne Argumente hat, fügt Java automatisch ein:

super();

am Anfang des Kindkonstruktors ein.

Deshalb müssen Sie es in vielen Fällen nicht manuell schreiben.

Allerdings, wenn die Elternklasse keinen Konstruktor ohne Argumente hat, schlägt der Code fehl, es sei denn, Sie rufen explizit den richtigen mit Argumenten auf.

7.3 Was ist der Unterschied zwischen super() und this()?

Sie rufen unterschiedliche Konstruktoren auf:

• super() → ruft einen Konstruktor in der Elternklasse auf
• this() → ruft einen Konstruktor in derselben Klasse auf

Beispielidee:

• Verwenden Sie this() um duplizierten Konstruktorcode zu reduzieren
• Verwenden Sie super() um den Elternteil des Objekts richtig zu initialisieren

7.4 Kann ich sowohl this() als auch super() im selben Konstruktor verwenden?

Nein, das können Sie nicht.

Grund:

• Sowohl this() als auch super() müssen die erste Anweisung im Konstruktor sein
• Nur eine Anweisung kann die erste sein

Deshalb zwingt Java Sie, eine zu wählen.

7.5 Kann ich super in einer statischen Methode verwenden?

Nein (im Allgemeinen).

super bezieht sich auf die aktuelle Objektinstanz, aber statische Methoden gehören zur Klasse selbst und haben keine Instanzreferenz.

Deshalb führt die Verwendung von super in statischen Methoden zu einem Kompilierfehler.

7.6 Erstellt super ein neues Elternobjekt?

Nein.

super erstellt kein neues Objekt.

Es greift einfach auf die Elternklassenansicht desselben Objekts zu.

Eine hilfreiche Art, darüber nachzudenken:

• this = dasselbe Objekt als Kind betrachtet
• super = dasselbe Objekt als Elternteil betrachtet

7.7 Wenn ich super.method() aufrufe, läuft dann immer nur die Elternlogik?

super.method() ruft immer die Elternversion dieser Methode auf.

Allerdings, wenn die Elternmethode intern eine andere Methode aufruft, die das Kind überschreibt, kann die Kindversion aufgrund der Java-Überschreibungsregeln ausgeführt werden.

Takeaway für Anfänger-Ebene:

super.method() ruft die Elternversion auf, aber Methodenaufrufe darin können immer noch von Überschreibungen betroffen sein.

7.8 Sollte ich super.field oft verwenden?

Normalerweise nein.

Wenn Sie häufig super.field benötigen, könnte das bedeuten, dass Ihr Design verwirrend ist, weil die Eltern- und Kindklasse denselben Feldnamen teilen.

In realen Projekten ist es besser, Feldverbergung zu vermeiden, es sei denn, Sie haben einen starken Grund (wie Legacy-Code oder externe Einschränkungen).

7.9 Kann super mit Interfaces verwendet werden?

Bei normaler Vererbung (extends) bezieht sich super auf die Elternklasse.

Allerdings erlaubt Java auch eine spezielle Syntax, um eine Standardmethode einer Schnittstelle aufzurufen:

InterfaceName.super.method();

Das ist fortgeschrittener, daher sollten Anfänger sich zuerst auf konzentrieren:

• Klassenvererbung
• super() / super.method() / super.field

7.10 Was ist der schnellste Weg, super zu meistern?

Ein einfacher Lernpfad:

1. Schreiben Sie eine grundlegende Eltern-/Kindklasse und bestätigen Sie die Konstruktorreihenfolge
2. Überschreiben Sie eine Methode und rufen Sie super.method() auf
3. Vergleichen Sie this vs super mit Feldern und Methoden
4. Üben Sie das Beheben von konstruktorbezogenen Fehlern

Die beste Praxis ist, kleine Beispiele zu schreiben und sie auszuführen.