Java Vererbung: Guide für Azubis, Studenten & Einsteiger

Stell dir vor, du entwickelst eine Software für einen Autohändler. Du brauchst Klassen für BMW, Mercedes und VW. Alle haben Gemeinsamkeiten: Sie haben einen Motor, eine Farbe und können fahren. Ohne Java Vererbung würdest du denselben Code dreimal schreiben. Das macht den Code unübersichtlich und fehleranfällig. Genau hier setzt die Java Vererbung an - sie hilft dir, Code wiederzuverwenden und sauber zu strukturieren.

Bevor du hier einsteigst, solltest du wissen, wie Java Klassen & Objekte funktionieren. Vererbung baut nämlich genau darauf auf.

Was ist Java Vererbung?

Java Vererbung (englisch: *Inheritance*) ist ein Kernkonzept der objektorientierten Programmierung. Dabei übernimmt eine Klasse Eigenschaften und Methoden von einer anderen Klasse. Stell dir vor, du hast einen Bauplan für ein allgemeines Fahrzeug. Jetzt willst du einen Bauplan für ein spezielles Auto erstellen. Anstatt alles neu zu zeichnen, nimmst du den Fahrzeug-Bauplan und fügst nur die Auto-spezifischen Details hinzu.

In Java realisierst du das mit dem Schlüsselwort `extends`. Die neue Klasse nennt man Kindklasse (oder Subklasse). Sie erbt von der Elternklasse (Superklasse). Die Kindklasse erhält automatisch alle Attribute und Methoden der Elternklasse - und kann eigene hinzufügen oder geerbte anpassen.

Merke: Vererbung bedeutet "Ist-ein"-Beziehung. Ein Auto *ist ein* Fahrzeug. Durch Vererbung schreibst du gemeinsame Logik nur einmal in der Elternklasse.

Wie funktioniert Vererbung in Java syntaktisch?

In Java nutzt du das Schlüsselwort `extends`, um eine Klasse von einer anderen erben zu lassen. Die Syntax ist simpel und übersichtlich. Schauen wir uns das direkt an einem Code-Beispiel an. Weitere Details findest du auch in den offiziellen Oracle Java Tutorials.

// Elternklasse (Superklasse)
public class Fahrzeug {

  String marke;
  int baujahr;

  public void fahren() {
    System.out.println("Das Fahrzeug faehrt.");
  }
}

// Kindklasse (Subklasse) erbt von Fahrzeug
public class Auto extends Fahrzeug {

  int anzahlTueren;

  public void hupeBetaetigen() {
    System.out.println("Hupe: Toet Toet!");
  }
}

Jetzt kann ein `Auto`-Objekt alles, was ein `Fahrzeug` kann - plus die neuen Methoden:

public class Main {

  public static void main(String[] args) {
    Auto meinAuto = new Auto();
    meinAuto.marke = "VW Golf"; // geerbtes Attribut
    meinAuto.baujahr = 2023; // geerbtes Attribut
    meinAuto.anzahlTueren = 5; // eigenes Attribut
    meinAuto.fahren(); // geerbte Methode
    meinAuto.hupeBetaetigen(); // eigene Methode
  }
}

Warum ist das nützlich? Weil du `fahren()` nicht für jedes Fahrzeug neu programmieren musst. Egal ob Auto, Motorrad oder LKW - die Grundlogik steht einmal in `Fahrzeug`. Das spart Zeit und reduziert Fehlerquellen.

Was sind Superklassen und Subklassen?

Die Begriffe Superklasse und Subklasse begegnet dir ständig. Hier ist die genaue Definition:

• Superklasse (Elternklasse): Die Klasse, die Eigenschaften zur Verfügung stellt. Sie steht weiter oben in der Hierarchie.

• Subklasse (Kindklasse): Die Klasse, die erbt. Sie steht weiter unten in der Hierarchie.

In Java ist jede Klasse (ohne explizite Angabe) eine direkte oder indirekte Subklasse der Klasse `Object`. `Object` ist die Wurzel aller Klassen in Java.

Java unterstützt nur einfache Vererbung (single inheritance): Eine Klasse kann nur von *einer* direkten Elternklasse erben. Mehrfachvererbung (von mehreren Klassen gleichzeitig) gibt es für Klassen in Java nicht. Das verhindert Komplikationen, falls zwei Elternklassen Methoden mit gleichem Namen haben.

Möchtest du Funktionen von mehreren Quellen nutzen, greifst du auf Interfaces zurück.

Was bedeutet Methodenüberschreibung (Override)?

Manchmal reicht die geerbte Methode nicht ganz. Eine Subklasse soll eine Methode anders ausführen als die Elternklasse. Das nennt man Methodenüberschreibung (englisch: *Method Overriding*). Die Methode in der Subklasse hat dabei denselben Namen, Rückgabetyp und dieselben Parameter.

public class Fahrzeug {

  public void beschleunigen() {
    System.out.println("Fahrzeug beschleunigt.");
  }
}

public class Sportwagen extends Fahrzeug {

  @Override
  public void beschleunigen() {
    System.out.println("Sportwagen beschleunigt rasant!");
  }
}

Die Annotation `@Override` ist optional, aber extrem empfehlenswert. Sie sagt dem Compiler: "Ich will hier eine Methode aus der Elternklasse überschreiben". Schreibst du dich beim Methodennamen vertipft, meckert der Compiler sofort. Ohne `@Override` würdest du stattdessen versehentlich eine neue Methode erstellen.

public class Main {

  public static void main(String[] args) {
    Fahrzeug f = new Fahrzeug();
    Sportwagen s = new Sportwagen();

    f.beschleunigen(); // Ausgabe: Fahrzeug beschleunigt.
    s.beschleunigen(); // Ausgabe: Sportwagen beschleunigt rasant!
  }
}

Was macht das Schlüsselwort super?

Mit `super` greifst du aus der Subklasse gezielt auf Elemente der Superklasse zu. Das ist besonders wichtig bei Konstruktoren. Denn: Konstruktoren werden *nicht* automatisch vererbt.

Hat deine Elternklasse einen Konstruktor mit Parametern, musst du diesen in der Subklasse explizit aufrufen:

public class Fahrzeug {

  String marke;

  // Konstruktor der Superklasse
  public Fahrzeug(String marke) {
    this.marke = marke;
  }
}

public class Auto extends Fahrzeug {

  int anzahlTueren;

  // Konstruktor der Subklasse
  public Auto(String marke, int anzahlTueren) {
    super(marke); // ruft Konstruktor von Fahrzeug auf
    this.anzahlTueren = anzahlTueren;
  }
}

Der `super()`-Aufruf muss immer die erste Anweisung im Konstruktor der Subklasse sein. Vergisst du ihn und die Elternklasse hat keinen Standardkonstruktor (ohne Parameter), wirft Java einen Fehler.

Du kannst mit `super` auch überschriebene Methoden der Elternklasse aufrufen, um deren Logik zu nutzen:

public class Sportwagen extends Fahrzeug {

  @Override
  public void beschleunigen() {
    super.beschleunigen(); // ruft Originalmethode auf
    System.out.println("...aber viel schneller!");
  }
}

Wie sieht ein Praxisbeispiel zur Java Vererbung aus?

Hier ist ein etwas komplexeres Beispiel, das du direkt in deiner Java IDE ausprobieren kannst. Wir modellieren eine Mitarbeiter-Hierarchie. Das zeigt, wie mehrfach Vererbung über mehrere Stufen funktioniert.

// Basisklasse
public class Mitarbeiter {

  String name;
  double gehalt;

  public Mitarbeiter(String name, double gehalt) {
    this.name = name;
    this.gehalt = gehalt;
  }

  public void arbeiten() {
    System.out.println(name + " arbeitet.");
  }

  public double berechneJahresgehalt() {
    return gehalt * 12;
  }
}

// Subklasse: Entwickler
public class Entwickler extends Mitarbeiter {

  String programmiersprache;

  public Entwickler(String name, double gehalt, String programmiersprache) {
    super(name, gehalt);
    this.programmiersprache = programmiersprache;
  }

  @Override
  public void arbeiten() {
    System.out.println(name + " codiert in " + programmiersprache);
  }
}

// Subklasse von Entwickler (2. Vererbungsstufe)
public class SeniorEntwickler extends Entwickler {

  int anzahlProjekte;

  public SeniorEntwickler(
    String name,
    double gehalt,
    String programmiersprache,
    int anzahlProjekte
  ) {
    super(name, gehalt, programmiersprache);
    this.anzahlProjekte = anzahlProjekte;
  }

  public void codeReview() {
    System.out.println(
      name + " macht Code-Review fuer " + anzahlProjekte + " Projekte."
    );
  }
}

Und so nutzt du die Klassen in der `main`-Methode:

public class Main {

  public static void main(String[] args) {
    Entwickler dev = new Entwickler("Lisa", 4000, "Java");
    dev.arbeiten();
    // Ausgabe: Lisa codiert in Java

    SeniorEntwickler senior = new SeniorEntwickler("Tom", 6000, "Java", 5);
    senior.arbeiten(); // geerbte, ueberschriebene Methode
    senior.codeReview(); // eigene Methode
    System.out.println("Jahresgehalt: " + senior.berechneJahresgehalt());
    // Ausgabe: Jahresgehalt: 72000.0
  }
}

Siehst du den Vorteil? Die Methode `berechneJahresgehalt()` wurde nur ganz oben in `Mitarbeiter` geschrieben. Sowohl `Entwickler` als auch `SeniorEntwickler` nutzen sie automatisch, ohne dass du den Code kopieren musst.

Welche Fehler gibt es bei der Java Vererbung?

Auch erfahrene Programmierer stolpern hier manchmal. Achte auf diese Klassiker.

Fehler 1: Konstruktoren werden nicht vererbt

Ein häufiger Irrtum ist, dass man den Konstruktor der Elternklasse einfach nutzen kann, ohne etwas zu tun. Das stimmt nicht. Du musst in der Subklasse einen Konstruktor definieren, der den Elternkonstruktor via `super(...)` aufruft.

Falsch:

public class Auto extends Fahrzeug {
  // Denke, der Fahrzeug-Konstruktor wird geerbt? Falsch gedacht.
}
// Fehler: Auto a = new Auto("BMW"); // Compilerfehler

Richtig:

public class Auto extends Fahrzeug {

  public Auto(String marke) {
    super(marke); // Expliziter Aufruf des Elternkonstruktors
  }
}

Fehler 2: private Attribute sind nicht direkt sichtbar

Vererbung kopiert zwar die `private` Attribute in die Subklasse, aber du kannst dort nicht direkt darauf zugreifen. `private` bedeutet wirklich "nur für diese Klasse". Nutze Getter- und Setter-Methoden oder ändere den Modifikator zu `protected` (wenn sinnvoll).

Falsch:

public class Auto extends Fahrzeug {

  public void zeigeMarke() {
    // System.out.println(marke);  // Fehler, da marke private ist
  }
}

Richtig:

public class Auto extends Fahrzeug {

  public void zeigeMarke() {
    System.out.println(getMarke()); // Zugriff oeffentlicher Getter
  }
}

Fehler 3: Statische Methoden "überschreiben"

Du kannst `static` Methoden in einer Subklasse neu definieren, aber das ist kein echtes Überschreiben. Man nennt das "Verdecken". Da statische Methoden zur Klasse gehören und nicht zum Objekt, wird die Methode ausgeführt, deren Typ die Variable hat - nicht das tatsächliche Objekt. Achte hier genau auf den Unterschied zwischen statischen und dynamischen Methodenaufrufen.

Wie kannst du Java Vererbung üben?

Theorie ist gut, Praxis ist besser. Erstelle eine kleine Vererbungshierarchie für ein Tierheim:

1. Schreibe eine Klasse `Tier` mit Attributen wie `name` und `alter` sowie einer Methode `macheGeraeusch()`.

2. Erstelle zwei Subklassen: `Hund` und `Katze`. Überschreibe `macheGeraeusch()` in beiden (z.B. "Wuff" und "Miau").

3. Füge `Hund` ein zusätzliches Attribut `rasse` hinzu.

Tipp: Wenn du deine IDE noch nicht eingerichtet hast, fang mit dem Hello World Programm an. Mehr Beispiele zu Syntax und Konzepten findest du auch bei W3Schools Java Inheritance.

FAQ: Häufige Fragen zu Java Vererbung

Kann eine Klasse von mehreren Klassen erben?

Nein, Java unterstützt keine Mehrfachvererbung bei Klassen (Multiple Inheritance). Eine Klasse kann nur genau eine direkte Elternklasse haben. Wenn du Verhalten von mehreren Quellen brauchst, nutze Interfaces mit dem Schlüsselwort `implements`.

Was ist der Unterschied zwischen Vererbung und Komposition?

Vererbung ist eine "Ist-ein"-Beziehung (ein Auto *ist ein* Fahrzeug). Komposition ist eine "Hat-ein"-Beziehung (ein Auto *hat einen* Motor). Oft ist Komposition flexibler, da sie die Klassen lockerer koppelt. Vererbung nutzt du, wenn die Hierarchie fest und logisch ist.

Wann sollte ich Vererbung nicht einsetzen?

Vermeide Vererbung, wenn es keine logische "Ist-ein"-Beziehung gibt. Ein klassisches Beispiel: Ein `Rechteck` sollte nicht von `Quadrat` erben, nur um Code wiederzuverwenden, da ein Quadrat mathematisch ein spezielles Rechteck ist, aber in der Softwareerweiterung oft unterschiedliche Regeln hat (z.B. Ändern der Breite).

Warum funktioniert super() nicht ohne Argumente?

Wenn die Superklasse keinen parameterlosen Konstruktor (Standardkonstruktor) hat, weil du selbst einen Konstruktor mit Argumenten geschrieben hast, bietet Java keinen Standardkonstruktor mehr an. Dann *muss* du in der Subklasse mit `super(argumente)` den passenden Konstruktor explizit aufrufen.

Kann ich Vererbung verhindern?

Ja. Wenn du möchtest, dass niemand von deiner Klasse erbt, deklarierst du sie als `final`. Ein bekanntes Beispiel in Java ist die Klasse `String`. Das verhindert, dass jemand die Funktionsweise von Strings verändern könnte.

Fazit

Java Vererbung ist ein mächtiges Werkzeug, um Code zu strukturieren und doppelte Arbeit zu vermeiden. Du nutzt `extends`, um Hierarchien zu bauen, `super`, um auf Elternfunktionalitäten zuzugreifen, und `@Override`, um Verhalten anzupassen. Denk immer an die "Ist-ein"-Regel. Wenn sie passt, ist Vererbung genau richtig.

Wenn du bei Vererbung oder anderen Java-Themen Unterstützung brauchst - sei es für eine IHK-Prüfung, eine Uni-Hausaufgabe oder dein erstes Berufsprojekt - schau dir study-it.education an. Dort bekommst du individuelle Nachhilfe von erfahrenen IT-Dozenten, die genau wissen, welche Herausforderungen Azubis, Studenten und Berufseinsteiger haben.