Von Nova Trent, Junior Entwicklerin bei Java Fleet Systems Consulting

Schwierigkeit: 🟢 Einsteiger
Lesezeit: 35–40 Minuten
Voraussetzungen: Tag 1–5 abgeschlossen

---

📋 Kursübersicht: Java OOP in 10 Tagen

Tag	Thema	Status
1	OOP-Konzepte & erste Klasse	✅ Abgeschlossen
2	Attribute & Methoden	✅ Abgeschlossen
3	Datenkapselung & Sichtbarkeit	✅ Abgeschlossen
4	Konstruktoren	✅ Abgeschlossen
5	Konstanten & Static	✅ Abgeschlossen 🔴
→ 6	Vererbung – Grundlagen	📍 Du bist hier
7	Vererbung – Polymorphie & Abstrakte Klassen	⏳
8	Typumwandlung & instanceof	⏳
9	Interfaces & Enumerationen	⏳
10	Ausnahmebehandlung	🔴 KOPFNUSS

Voraussetzung: Tag 1–5 abgeschlossen
Folgekurs: Erweiterte Techniken (Kurs 3)

---

🔄 Kurz-Wiederholung: Challenge von Tag 5

Die Aufgabe war: Erstelle eine Konto-Klasse mit Static-Elementen.

Lösung:

public class Konto {
    // Static Konstanten
    public static final double MINDEST_EINLAGE = 100.0;
    public static final double MAX_TAGESABHEBUNG = 1000.0;
    public static final String IBAN_PREFIX = "DE";
    
    // Static Zähler
    private static int anzahlKonten = 0;
    
    // Instanzvariablen
    private final String iban;
    private double kontostand;
    
    // Konstruktor
    public Konto(double startguthaben) {
        if (startguthaben < MINDEST_EINLAGE) {
            throw new IllegalArgumentException(
                "Mindesteinlage ist " + MINDEST_EINLAGE + "€!"
            );
        }
        this.iban = generiereIBAN();
        this.kontostand = startguthaben;
    }
    
    // Static Methoden
    public static int getAnzahlKonten() {
        return anzahlKonten;
    }
    
    private static String generiereIBAN() {
        anzahlKonten++;
        return IBAN_PREFIX + String.format("%020d", anzahlKonten);
    }
    
    // Getter
    public String getIban() { return iban; }
    public double getKontostand() { return kontostand; }
}

Hast du’s? Super! Heute wird’s richtig spannend — wir lernen Vererbung! 🎉

---

⚡ Das Wichtigste in 30 Sekunden

Dein Problem: Du hast Auto, Motorrad, LKW — alle haben marke, baujahr, fahren(). Du schreibst den gleichen Code dreimal!

Die Lösung: Vererbung! Erstelle eine Elternklasse Fahrzeug mit dem gemeinsamen Code. Die Kindklassen erben automatisch alles.

Heute lernst du:

• ✅ extends — eine Klasse von einer anderen ableiten
• ✅ Was wird vererbt, was nicht?
• ✅ super() — den Konstruktor der Elternklasse aufrufen
• ✅ super.methode() — auf Eltern-Methoden zugreifen

Für wen ist dieser Artikel?

• 🌱 OOP-Neulinge: Du lernst Vererbung von Grund auf
• 🌿 OOP-Umsteiger: Du siehst Java-Spezifika (vs. C#, C++)
• 🌳 Profis: Im Bonus: Komposition vs. Vererbung, Sealed Classes

Zeit-Investment: 35–40 Minuten

---

👋 Nova: „Das ist DAS Kernkonzept von OOP!“

Hey! 👋

Nova hier.

Okay, heute wird’s richtig wichtig. Vererbung ist eines der vier Grundprinzipien von OOP — zusammen mit Kapselung, Abstraktion und Polymorphie.

Stell dir vor: Du baust ein Spiel mit verschiedenen Fahrzeugen. Autos, Motorräder, LKWs. Alle haben:

• Eine Marke
• Ein Baujahr
• Eine fahren()-Methode

Ohne Vererbung schreibst du das dreimal. Mit Vererbung schreibst du es EINMAL in einer Fahrzeug-Klasse, und alle anderen erben es automatisch.

Real talk: Als Elyndra mir das zum ersten Mal gezeigt hat, war ich begeistert. „Wait, ich schreibe den Code einmal und ALLE Klassen haben ihn?!“ Ja. Genau so funktioniert’s.

Los geht’s! 🚀

---

🟢 GRUNDLAGEN

Das Problem: Code-Duplikation

Ohne Vererbung:

public class Auto {
    private String marke;
    private int baujahr;
    private int anzahlTueren;
    
    public void fahren() {
        System.out.println("Das Fahrzeug fährt!");
    }
    // ... viele weitere Methoden
}

public class Motorrad {
    private String marke;      // Duplikat!
    private int baujahr;       // Duplikat!
    private boolean hatHelm;
    
    public void fahren() {     // Duplikat!
        System.out.println("Das Fahrzeug fährt!");
    }
}

public class LKW {
    private String marke;      // Duplikat!
    private int baujahr;       // Duplikat!
    private int ladekapazitaet;
    
    public void fahren() {     // Duplikat!
        System.out.println("Das Fahrzeug fährt!");
    }
}

Probleme:

• Gleicher Code dreimal geschrieben
• Änderungen müssen dreimal gemacht werden
• Fehler schleichen sich ein, wenn du eine Stelle vergisst

Die Lösung: Vererbung mit extends

// ELTERNKLASSE (auch: Basisklasse, Superklasse)
public class Fahrzeug {
    protected String marke;
    protected int baujahr;
    
    public Fahrzeug(String marke, int baujahr) {
        this.marke = marke;
        this.baujahr = baujahr;
    }
    
    public void fahren() {
        System.out.println("Das Fahrzeug fährt!");
    }
    
    public String getMarke() {
        return marke;
    }
}

// KINDKLASSE (auch: Subklasse, abgeleitete Klasse)
public class Auto extends Fahrzeug {
    private int anzahlTueren;
    
    public Auto(String marke, int baujahr, int anzahlTueren) {
        super(marke, baujahr);  // Ruft Fahrzeug-Konstruktor auf
        this.anzahlTueren = anzahlTueren;
    }
    
    public void hupen() {
        System.out.println("HUUUP!");
    }
}

Auto auto = new Auto("VW", 2024, 4);
auto.fahren();      // Von Fahrzeug geerbt!
auto.getMarke();    // Von Fahrzeug geerbt!
auto.hupen();       // Eigene Methode von Auto

Abbildung 1: Kindklassen erben alle public/protected Attribute und Methoden von der Elternklasse — und können eigene hinzufügen.

Was bedeutet „erben“?

Wenn Auto extends Fahrzeug:

• Auto ist ein Fahrzeug (IS-A Beziehung)
• Auto hat automatisch alle nicht-privaten Attribute und Methoden von Fahrzeug
• Auto kann eigene Attribute und Methoden hinzufügen
• Auto kann geerbte Methoden überschreiben (dazu mehr in Tag 7)

Was wird vererbt — und was nicht?

Abbildung 2: public und protected werden vererbt. private und Konstruktoren werden NICHT vererbt.

Element	Wird vererbt?	Details
public Attribute/Methoden	✅ Ja	Immer verfügbar
protected Attribute/Methoden	✅ Ja	Für Kindklassen gedacht
Package-private (default)	✅ Teilweise	Nur im gleichen Package
private Attribute/Methoden	❌ Nein	Niemals!
Konstruktoren	❌ Nein	Müssen mit super() aufgerufen werden
static Methoden	⚠️ Versteckt	Technisch nicht vererbt

protected — Für Vererbung gemacht

protected ist wie private, aber Kindklassen haben Zugriff:

public class Fahrzeug {
    private String geheimnis;      // Nicht mal Kindklassen sehen das
    protected String marke;        // Kindklassen sehen das
    public String kennzeichen;     // Alle sehen das
}

public class Auto extends Fahrzeug {
    public void test() {
        // System.out.println(geheimnis);  // ❌ FEHLER! private
        System.out.println(marke);          // ✅ OK! protected
        System.out.println(kennzeichen);    // ✅ OK! public
    }
}

super() — Konstruktor der Elternklasse aufrufen

Konstruktoren werden NICHT vererbt. Die Kindklasse muss den Eltern-Konstruktor explizit aufrufen:

public class Fahrzeug {
    protected String marke;
    protected int baujahr;
    
    public Fahrzeug(String marke, int baujahr) {
        this.marke = marke;
        this.baujahr = baujahr;
        System.out.println("Fahrzeug erstellt!");
    }
}

public class Auto extends Fahrzeug {
    private int anzahlTueren;
    
    public Auto(String marke, int baujahr, int anzahlTueren) {
        super(marke, baujahr);  // MUSS erste Zeile sein!
        this.anzahlTueren = anzahlTueren;
        System.out.println("Auto erstellt!");
    }
}

Auto auto = new Auto("BMW", 2024, 4);
// Ausgabe:
// Fahrzeug erstellt!
// Auto erstellt!

Abbildung 3: super() ruft den Konstruktor der Elternklasse auf — muss erste Anweisung sein!

Regeln für super():

• Muss erste Anweisung im Konstruktor sein
• Wenn du kein super() schreibst und die Elternklasse einen Default-Konstruktor hat → Java ruft automatisch super() auf
• Wenn die Elternklasse keinen Default-Konstruktor hat → Compilerfehler!

super.methode() — Eltern-Methode aufrufen

Du kannst auch auf Methoden der Elternklasse zugreifen:

public class Fahrzeug {
    public void fahren() {
        System.out.println("Das Fahrzeug fährt!");
    }
}

public class Auto extends Fahrzeug {
    @Override
    public void fahren() {
        super.fahren();  // Erst Eltern-Methode aufrufen
        System.out.println("Das Auto hupt zusätzlich!");
    }
}

Auto auto = new Auto();
auto.fahren();
// Ausgabe:
// Das Fahrzeug fährt!
// Das Auto hupt zusätzlich!

Mehrfachvererbung? Gibt’s nicht!

In Java kann eine Klasse nur von einer Klasse erben:

// ❌ FEHLER! Java unterstützt keine Mehrfachvererbung
public class Amphibienfahrzeug extends Auto, Boot {
}

// ✅ Alternative: Interface (Tag 9)
public class Amphibienfahrzeug extends Fahrzeug implements Schwimmfaehig {
}

Die Mutter aller Klassen: Object

Jede Klasse in Java erbt automatisch von Object:

public class Auto {
    // extends Object ist implizit!
}

// Deshalb hat jedes Objekt diese Methoden:
auto.toString();    // Von Object geerbt
auto.equals(other); // Von Object geerbt
auto.hashCode();    // Von Object geerbt

---

🟡 PROFESSIONALS

Schon OOP-Erfahrung aus C#, C++, PHP? Hier sind die Java-Besonderheiten.

Für C#-Umsteiger: : statt extends

// C#
public class Auto : Fahrzeug {
    public Auto(string marke) : base(marke) { }
}

// Java
public class Auto extends Fahrzeug {
    public Auto(String marke) {
        super(marke);  // Im Body, nicht nach Signatur!
    }
}

Für C++-Umsteiger: Keine Mehrfachvererbung

// C++ — Mehrfachvererbung möglich
class Amphibie : public Auto, public Boot { };

// Java — Nur einfache Vererbung!
// Interfaces als Alternative:
public class Amphibie extends Fahrzeug implements Fahrbar, Schwimmbar { }

Für PHP-Umsteiger: Ähnliche Syntax

// PHP
class Auto extends Fahrzeug {
    public function __construct($marke) {
        parent::__construct($marke);  // parent:: statt super
    }
}

// Java
public class Auto extends Fahrzeug {
    public Auto(String marke) {
        super(marke);  // super statt parent::
    }
}

Lombok: @SuperBuilder

Mit Lombok für Vererbung:

import lombok.experimental.SuperBuilder;

@SuperBuilder
public class Fahrzeug {
    protected String marke;
    protected int baujahr;
}

@SuperBuilder
public class Auto extends Fahrzeug {
    private int anzahlTueren;
}

// Nutzung:
Auto auto = Auto.builder()
    .marke("VW")
    .baujahr(2024)
    .anzahlTueren(4)
    .build();

---

🔵 BONUS

Für Wissbegierige: Komposition vs. Vererbung, Sealed Classes.

Wann Vererbung — und wann nicht?

Verwende Vererbung wenn:

• Eine echte „IS-A“ Beziehung besteht
• Auto IS-A Fahrzeug ✅
• Hund IS-A Tier ✅

Vermeide Vererbung wenn:

• Es nur um Code-Wiederverwendung geht
• Die Beziehung eher „HAS-A“ ist

// ❌ FALSCH: Vererbung missbraucht
class Auto extends Motor {  // Auto IS-A Motor? Nein!
}

// ✅ RICHTIG: Komposition
class Auto {
    private Motor motor;  // Auto HAS-A Motor
}

Komposition über Vererbung

Das berühmte Prinzip aus „Effective Java“:

// Statt Vererbung...
class LoggingList extends ArrayList<String> {
    @Override
    public boolean add(String s) {
        System.out.println("Adding: " + s);
        return super.add(s);
    }
}

// ...lieber Komposition (Wrapper/Decorator)
class LoggingList {
    private final List<String> list = new ArrayList<>();
    
    public boolean add(String s) {
        System.out.println("Adding: " + s);
        return list.add(s);
    }
    
    // Weitere Methoden delegieren...
}

Sealed Classes (Java 17+)

Kontrolliere, welche Klassen erben dürfen:

public sealed class Fahrzeug permits Auto, Motorrad, LKW {
    // Nur Auto, Motorrad, LKW dürfen erben!
}

public final class Auto extends Fahrzeug {
    // final = keine weiteren Kindklassen
}

public non-sealed class Motorrad extends Fahrzeug {
    // non-sealed = jeder darf von Motorrad erben
}

---

💬 Real Talk

Tom fragt, Nova erklärt — Die Fragen, die sich jeder stellt.

Java Fleet Büro, 11:00 Uhr. Tom starrt auf ein UML-Diagramm, Nova kommt vorbei.

---

Tom: Nova, ich versteh nicht, wann ich protected und wann private nehmen soll. Bei Vererbung ist doch alles protected, oder?

Nova: setzt sich Nope! protected nur wenn Kindklassen wirklich Zugriff brauchen. Ansonsten: private + Getter/Setter.

Tom: Aber dann muss ich mehr tippen…

Nova: Stimmt. Aber stell dir vor: Du änderst später, wie marke intern gespeichert wird. Bei private + Getter musst du nur den Getter ändern. Bei protected muss jede Kindklasse angepasst werden.

Tom: Hmm… okay. Und wann erbe ich überhaupt? Ich könnte doch alles mit Komposition machen?

Nova: lacht Gute Frage! Die Faustregel: „IS-A“ → Vererbung. „HAS-A“ → Komposition. Ein Auto IST ein Fahrzeug → Vererbung. Ein Auto HAT einen Motor → Komposition.

Tom: Das klingt logisch. Aber was, wenn beides irgendwie passt?

Nova: Dann meist Komposition. Es gibt das Sprichwort „Favor composition over inheritance“. Vererbung ist mächtig, aber auch gefährlich. Wenn die Elternklasse sich ändert, brechen alle Kindklassen.

Tom: Verstehe. Noch was: Wenn ich super() vergesse?

Nova: Dann ruft Java automatisch den Default-Konstruktor auf — super() ohne Parameter. Wenn die Elternklasse aber keinen Default-Konstruktor hat…

Tom: …Compilerfehler?

Nova: Exakt! „There is no default constructor available in Fahrzeug“. Passiert mir manchmal immer noch. 😅

---

✅ Checkpoint: Hast du es verstanden?

Quiz

Frage 1: Was bedeutet class Auto extends Fahrzeug?

Frage 2: Welche Sichtbarkeitsmodifier werden vererbt?

Frage 3: Was macht super(marke, baujahr) im Konstruktor?

Frage 4: Kann eine Java-Klasse von mehreren Klassen erben?

Frage 5: Du siehst diesen Code:

public class Tier {
    public Tier(String name) { }
}

public class Hund extends Tier {
    public Hund() {
        System.out.println("Wuff!");
    }
}

Kompiliert das? Warum (nicht)?

---

Mini-Challenge

Aufgabe: Erstelle eine Vererbungshierarchie für Mitarbeiter:

1. Elternklasse Mitarbeiter:
   • Attribute: name, personalnummer, gehalt
   • Konstruktor mit allen Parametern
   • Methode: arbeiten() — gibt „Name arbeitet.“ aus
   • Methode: getJahresgehalt() — gibt gehalt * 12 zurück
2. Kindklasse Entwickler extends Mitarbeiter:
   • Zusätzliches Attribut: programmiersprache
   • Konstruktor ruft super() auf
   • Überschreibt arbeiten() — gibt „Name programmiert in Sprache.“ aus
   • Neue Methode: coden() — gibt „Tipptipptipp…“ aus
3. Kindklasse Manager extends Mitarbeiter:
   • Zusätzliches Attribut: teamgroesse
   • Konstruktor ruft super() auf
   • Überschreibt getJahresgehalt() — addiert 10% Bonus
   • Neue Methode: meeting() — gibt „Meeting um 9 Uhr!“ aus

Lösung: Findest du am Anfang von Tag 7! 🚀

---

❓ FAQ — Häufig gestellte Fragen

Frage 1: Muss ich immer super() aufrufen?

Nicht explizit, wenn die Elternklasse einen Default-Konstruktor (ohne Parameter) hat. Java ruft dann automatisch super() auf. Aber wenn die Elternklasse nur Konstruktoren mit Parametern hat → ja, du musst super(...) aufrufen.

---

Frage 2: Kann ich von einer final-Klasse erben?

Nein! final class bedeutet: „Keine Vererbung erlaubt.“

public final class String { }  // Deshalb kann niemand von String erben!

---

Frage 3: Erbt die Kindklasse auch private Methoden?

Die Methoden existieren im Objekt, aber die Kindklasse hat keinen Zugriff. Sie sind „technisch da“, aber nicht sichtbar.

---

Frage 4: Was passiert, wenn Eltern- und Kindklasse eine Methode mit gleichem Namen haben?

Die Kindklasse überschreibt die Eltern-Methode. Dazu mehr in Tag 7 (Polymorphie)!

---

Frage 5: Kann ich mehrere Klassen in einer Vererbungskette haben?

Ja! A extends B, B extends C ist erlaubt. Das nennt sich Vererbungshierarchie.

class Fahrzeug { }
class Auto extends Fahrzeug { }
class Sportwagen extends Auto { }  // Erbt von Auto UND indirekt von Fahrzeug

---

Frage 6: Wann sollte ich protected statt private + Getter verwenden?

protected wenn Kindklassen das Attribut direkt verändern sollen (selten!). Meist ist private + Getter sicherer, weil du die Kontrolle behältst.

---

Frage 7: Bernd meinte „Vererbung ist Gift“. Übertreibt er?

schmunzelt Classic Bernd. Er hat einen Punkt: Übermäßige Vererbung führt zu fragilen Klassenhierarchien. Eine Änderung in der Elternklasse kann alle Kindklassen brechen.

Aber Vererbung ist nicht „Gift“ — sie ist ein Werkzeug. Für echte „IS-A“ Beziehungen ist sie perfekt. Für alles andere: Komposition. Bernd bevorzugt halt immer Komposition. Nach 40 Jahren hat er zu viele kaputte Vererbungshierarchien gesehen. 🤷

---

📚 Quiz-Lösungen

Frage 1: Was bedeutet class Auto extends Fahrzeug?

Antwort:

Auto erbt von Fahrzeug. Das bedeutet:

• Auto ist eine Kindklasse (Subklasse) von Fahrzeug
• Auto hat alle nicht-privaten Attribute und Methoden von Fahrzeug
• Ein Auto IST ein Fahrzeug

---

Frage 2: Welche Sichtbarkeitsmodifier werden vererbt?

Antwort:

• public ✅ immer
• protected ✅ immer
• Package-private (default) ✅ wenn im gleichen Package
• private ❌ nie

---

Frage 3: Was macht super(marke, baujahr) im Konstruktor?

Antwort:

Es ruft den Konstruktor der Elternklasse auf und übergibt marke und baujahr als Parameter. Der Eltern-Konstruktor initialisiert dann die geerbten Attribute.

---

Frage 4: Kann eine Java-Klasse von mehreren Klassen erben?

Antwort:

Nein! Java unterstützt keine Mehrfachvererbung von Klassen. Eine Klasse kann nur von EINER Klasse erben.

Alternative: Eine Klasse kann mehrere Interfaces implementieren (Tag 9).

---

Frage 5: Kompiliert das?

public class Tier {
    public Tier(String name) { }
}

public class Hund extends Tier {
    public Hund() {
        System.out.println("Wuff!");
    }
}

Antwort:

Nein! Compilerfehler: „There is no default constructor available in ‚Tier'“

Tier hat nur einen Konstruktor mit Parameter. Hund muss explizit super("...") aufrufen:

public Hund() {
    super("Hund");  // Muss ergänzt werden!
    System.out.println("Wuff!");
}

---

🎉 Tag 6 geschafft!

Du hast es geschafft! 🚀

Das hast du heute gelernt:

• ✅ extends für Vererbung
• ✅ Was wird vererbt (public, protected) und was nicht (private, Konstruktoren)
• ✅ super() für Konstruktor-Aufruf
• ✅ super.methode() für Eltern-Methoden
• ✅ Wann Vererbung sinnvoll ist (IS-A Beziehung)

Das war wichtig — Vererbung ist ein OOP-Kernkonzept! 💪

---

🔮 Wie geht’s weiter?

Morgen in Tag 7: Polymorphie & Abstrakte Klassen

Das wird noch spannender! Du lernst:

• @Override — Methoden überschreiben
• Polymorphie — Ein Objekt, viele Formen
• abstract — Klassen ohne Instanzen
• Abstrakte Methoden — „Muss implementiert werden!“

Das macht Vererbung erst richtig mächtig! 🎯

---

📦 Downloads

Starter-Projekt für Tag 6:

⬇️ Tag06_Vererbung.zip — Komplettes Maven-Projekt

Inhalt:

Tag06_Vererbung/
├── pom.xml
├── README.md
└── src/main/java/
    └── de/javafleet/oop/
        ├── Main.java
        └── model/
            ├── Fahrzeug.java       (Elternklasse)
            ├── Auto.java           (extends Fahrzeug)
            ├── Motorrad.java       (extends Fahrzeug)
            └── Konto.java          (Lösung Tag 5)

---

🔧 Troubleshooting

Problem: „There is no default constructor available“

error: constructor Fahrzeug in class Fahrzeug cannot be applied to given types

Lösung: Die Elternklasse hat keinen Default-Konstruktor. Du musst super(...) mit passenden Parametern aufrufen.

---

Problem: „call to super must be first statement“

error: call to super must be first statement in constructor

Lösung: super() muss die erste Zeile im Konstruktor sein!

---

Problem: „marke has private access in Fahrzeug“

error: marke has private access in Fahrzeug

Lösung: private Attribute werden nicht vererbt. Ändere zu protected oder nutze Getter.

---

🔗 Resources & Links

🟢 Für Einsteiger

Ressource	Beschreibung	Sprache
Oracle — Inheritance	Offizielle Doku	🇬🇧
W3Schools — Java Inheritance	Einfache Erklärungen	🇬🇧

🟡 Für Fortgeschrittene

Ressource	Beschreibung	Sprache
Baeldung — Inheritance	Tiefgehende Erklärung	🇬🇧
Effective Java — Item 18	Composition over Inheritance	🇬🇧

---

👋 Bis morgen!

Tag 6 ist durch. Du verstehst jetzt Vererbung!

Morgen: Polymorphie & Abstrakte Klassen — das macht Vererbung erst richtig mächtig.

See you! 🚀

---

Nova Trent
Junior Entwicklerin bei Java Fleet Systems Consulting
„Auto extends Fahrzeug — so einfach ist Vererbung!“ 🚗

---

Praxis-Challenge

🎯 Medien-Bibliothek

Schwierigkeit: 🟢 Einsteiger
Geschätzte Zeit: 45–60 Minuten
Voraussetzungen: Tag 1–6 abgeschlossen

---

Szenario

Du baust ein Verwaltungssystem für eine Bibliothek. Verschiedene Medientypen (Bücher, Filme, Hörbücher) teilen gemeinsame Eigenschaften, haben aber auch ihre Besonderheiten.

---

Deine Aufgaben

1. Basisklasse Medium

Erstelle die Elternklasse für alle Medien:

Element	Details
Attribute	titel (String), erscheinungsjahr (int), ausgeliehen (boolean)
Sichtbarkeit	Attribute protected, damit Kindklassen Zugriff haben
Konstruktor	Parameter: titel, erscheinungsjahr. ausgeliehen startet immer mit false
Methode	getInfo() → gibt zurück: "Titel (Jahr)"
Methode	ausleihen() → setzt ausgeliehen = true, gibt aus: "[Titel] wurde ausgeliehen."
Methode	zurueckgeben() → setzt ausgeliehen = false, gibt aus: "[Titel] wurde zurückgegeben."
Methode	istAusgeliehen() → gibt ausgeliehen zurück

---

2. Kindklasse Buch extends Medium

Element	Details
Zusätzliche Attribute	autor (String), seitenanzahl (int)
Konstruktor	Ruft super() auf, initialisiert alle 4 Attribute
Überschreibt	getInfo() → "Titel von Autor (Jahr, XXX Seiten)"
Neue Methode	lesezeit(int seitenProStunde) → gibt geschätzte Lesezeit in Stunden zurück (int)

---

3. Kindklasse Film extends Medium

Element	Details
Zusätzliche Attribute	regisseur (String), laengeInMinuten (int)
Konstruktor	Ruft super() auf, initialisiert alle 4 Attribute
Überschreibt	getInfo() → "Titel von Regisseur (Jahr, XXX Min)"
Überschreibt	ausleihen() → ruft erst super.ausleihen() auf, gibt dann zusätzlich aus: "Viel Spaß beim Schauen!"

---

4. Kindklasse Hoerbuch extends Buch

Achtung: Vererbungskette! Hoerbuch erbt von Buch, das von Medium erbt.

Element	Details
Zusätzliche Attribute	sprecher (String), dauerInMinuten (int)
Konstruktor	Ruft super() auf, initialisiert alle 6 Attribute
Überschreibt	getInfo() → "Titel von Autor (Jahr), gelesen von Sprecher (XXX Min)"
Überschreibt	lesezeit(int seitenProStunde) → ignoriert den Parameter! Gibt stattdessen dauerInMinuten / 60 zurück

---

Test-Code für Main

public class Main {
    public static void main(String[] args) {
        // Objekte erstellen
        Buch buch = new Buch("Clean Code", 2008, "Robert C. Martin", 464);
        Film film = new Film("Matrix", 1999, "Wachowskis", 136);
        Hoerbuch hb = new Hoerbuch("Der Herr der Ringe", 1954, 
                                    "J.R.R. Tolkien", 1200, 
                                    "Rufus Beck", 2400);
        
        // getInfo() testen
        System.out.println("=== Medien-Info ===");
        System.out.println(buch.getInfo());
        System.out.println(film.getInfo());
        System.out.println(hb.getInfo());
        
        // ausleihen() testen
        System.out.println("\n=== Ausleihen ===");
        buch.ausleihen();
        film.ausleihen();  // Soll zusätzliche Nachricht ausgeben!
        
        // Lesezeit testen
        System.out.println("\n=== Lesezeit ===");
        System.out.println("Buch (30 Seiten/h): " + buch.lesezeit(30) + " Stunden");
        System.out.println("Hörbuch: " + hb.lesezeit(30) + " Stunden");  // Parameter wird ignoriert!
        
        // Status prüfen
        System.out.println("\n=== Status ===");
        System.out.println("Buch ausgeliehen? " + buch.istAusgeliehen());
        System.out.println("Film ausgeliehen? " + film.istAusgeliehen());
        
        // Zurückgeben
        System.out.println("\n=== Zurückgeben ===");
        buch.zurueckgeben();
        System.out.println("Buch noch ausgeliehen? " + buch.istAusgeliehen());
    }
}

---

Erwartete Ausgabe

=== Medien-Info ===
Clean Code von Robert C. Martin (2008, 464 Seiten)
Matrix von Wachowskis (1999, 136 Min)
Der Herr der Ringe von J.R.R. Tolkien (1954), gelesen von Rufus Beck (2400 Min)

=== Ausleihen ===
Clean Code wurde ausgeliehen.
Matrix wurde ausgeliehen.
Viel Spaß beim Schauen!

=== Lesezeit ===
Buch (30 Seiten/h): 15 Stunden
Hörbuch: 40 Stunden

=== Status ===
Buch ausgeliehen? true
Film ausgeliehen? true

=== Zurückgeben ===
Clean Code wurde zurückgegeben.
Buch noch ausgeliehen? false

---

Checkliste: Das wird getestet

• [ ] extends korrekt verwendet
• [ ] Vererbungskette: Hoerbuch → Buch → Medium
• [ ] super() im Konstruktor aufgerufen
• [ ] super.ausleihen() in Film verwendet
• [ ] @Override Annotation bei überschriebenen Methoden
• [ ] protected Attribute in Basisklasse
• [ ] Methoden-Überschreibung mit Erweiterung (Film.ausleihen)
• [ ] Methoden-Überschreibung mit komplettem Ersatz (Hoerbuch.lesezeit)

---

Hinweise

1. Reihenfolge: Erstelle zuerst Medium, dann Buch, dann Film, dann Hoerbuch
2. super() muss erste Zeile sein im Konstruktor
3. Vergiss @Override nicht — es schützt vor Tippfehlern
4. Integer-Division: 464 / 30 = 15 (nicht 15.47)

---

Projektstruktur

src/main/java/
└── de/javafleet/oop/
    ├── Main.java
    └── model/
        ├── Medium.java
        ├── Buch.java
        ├── Film.java
        └── Hoerbuch.java

---

© 2025 Java Fleet Systems Consulting | java-developer.online

Tags: #Java #OOP #Vererbung #Inheritance #extends #super #Tutorial