Kapitel 11: OOP 3 Säulen

🎯 Lernziele

• Kapselung (Encapsulation) vertiefen
• Vererbung (Inheritance) mit extends
• Methodenüberschreibung (Method Overriding)
• super Schlüsselwort
• Polymorphismus (Polymorphism)

11.1 Kapselung (Encapsulation) vertiefen

🔒 Was ist Kapselung?

Kapselung = Attribute privat machen (private) und nur über öffentliche Methoden (getter/setter) zugreifen.

📋 Beispiel: Vollständige Kapselung

class Person {
    // Privat (von außen nicht zugreifbar!)
    private String name;
    private int alter;
    
    // Öffentliche getter (lesen)
    public String getName() {
        return name;
    }
    
    // Öffentliche setter (schreiben + validieren)
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAlter(int alter) {
        if (alter >= 0 && alter <= 150) {  // Validierung!
            this.alter = alter;
        } else {
            System.out.println("Ungültiges Alter!");
        }
    }
    
    public int getAlter() {
        return alter;
    }
}

public class KapselungBeispiel {
    public static void main(String[] args) {
        Person p = new Person();
        
        // Über setter setzen
        p.setName("Max");
        p.setAlter(25);
        
        // Über getter lesen
        System.out.println("Name: " + p.getName());  // Max
        System.out.println("Alter: " + p.getAlter());  // 25
        
        // Ungültiges Alter (wird abgewiesen!)
        p.setAlter(200);  // Ungültiges Alter!
    }
}

11.2 Vererbung (Inheritance) mit extends

🌳 Was ist Vererbung?

Vererbung = Eine Klasse (Kindklasse/Subklasse) erbt Attribute und Methoden von einer anderen Klasse (Elternklasse/Superklasse).

Vorteile:

• ✅ Code-Wiederverwendung (Duplikate vermeiden)
• ✅ Hierarchie (Beziehungen zwischen Klassen)
• ✅ Erweiterbarkeit

📝 Syntax

class ElternKlasse {
    // Attribute und Methoden
}

class KindKlasse extends ElternKlasse {
    // Erbt alles von ElternKlasse + eigene Erweiterungen
}

📋 Beispiel: Tier (Superklasse) und Hund (Subklasse)

// Superklasse (Eltern)
class Tier {
    String name;
    
    void essen() {
        System.out.println(name + " frisst.");
    }
}

// Subklasse (Kind)
class Hund extends Tier {
    void bellen() {
        System.out.println(name + " bellt: Wuff!");
    }
}

public class VererbungBeispiel {
    public static void main(String[] args) {
        Hund hund = new Hund();
        
        // Von Superklasse geerbt!
        hund.name = "Bello";
        hund.essen();  // Bello frisst.
        
        // Eigene Methode der Subklasse
        hund.bellen();  // Bello bellt: Wuff!
    }
}

11.3 Methodenüberschreibung (Method Overriding)

🔄 Was ist Methodenüberschreibung?

Methodenüberschreibung = Subklasse definiert eine Methode mit gleichem Namen und gleichen Parametern wie die Superklasse neu.

→ Ersetzt die geerbte Methode durch eine spezifischere Version!

📋 Beispiel: Tier und Hund (Methode überschreiben)

class Tier {
    void stimulus() {
        System.out.println("Tier macht Geräusch.");
    }
}

class Hund extends Tier {
    // Methodenüberschreibung (gleicher Name + Parameter!)
    @Override  // Annotation (optional, aber empfohlen!)
    void stimulus() {
        System.out.println("Hund bellt: Wuff!");
    }
}

class Katze extends Tier {
    @Override
    void stimulus() {
        System.out.println("Katze miaut: Miau!");
    }
}

public class UeberschreibungBeispiel {
    public static void main(String[] args) {
        Tier tier = new Tier();
        tier.stimulus();  // Tier macht Geräusch.
        
        Hund hund = new Hund();
        hund.stimulus();  // Hund bellt: Wuff!
        
        Katze katze = new Katze();
        katze.stimulus();  // Katze miaut: Miau!
    }
}

⚠️ Wichtig: @Override Annotation

@Override = Überprüft, ob du wirklich eine Methode überschreibst (Fehlervermeidung!).

11.4 super Schlüsselwort

🔼 Was ist super?

super = Referenz zur Superklasse (Elternklasse).

Verwendung:

1. Aufruf von Superklassen-Konstruktor (super())
2. Aufruf von Superklassen-Methode (super.methode())
3. Zugriff auf Superklassen-Attribut (super.attribut)

📋 Beispiel 1: super() (Konstruktor aufrufen)

class Tier {
    String name;
    
    // Konstruktor der Superklasse
    Tier(String name) {
        this.name = name;
    }
}

class Hund extends Tier {
    String rasse;
    
    // Konstruktor der Subklasse
    Hund(String name, String rasse) {
        super(name);  // Ruft Tier(name) auf!
        this.rasse = rasse;
    }
}

public class SuperBeispiel1 {
    public static void main(String[] args) {
        Hund hund = new Hund("Bello", "Labrador");
        System.out.println(hund.name);   // Bello
        System.out.println(hund.rasse);  // Labrador
    }
}

📋 Beispiel 2: super.methode() (Methode aufrufen)

class Tier {
    void stimulus() {
        System.out.println("Tier macht Geräusch.");
    }
}

class Hund extends Tier {
    @Override
    void stimulus() {
        super.stimulus();  // Ruft Tier.stimulus() auf!
        System.out.println("Hund bellt: Wuff!");
    }
}

public class SuperBeispiel2 {
    public static void main(String[] args) {
        Hund hund = new Hund();
        hund.stimulus();
        // Ausgabe:
        // Tier macht Geräusch.
        // Hund bellt: Wuff!
    }
}

11.5 Polymorphismus (Polymorphism)

🎭 Was ist Polymorphismus?

Polymorphismus = Ein Objekt kann viele Formen haben (als Superklasse und als Subklasse behandelt werden).

2 Arten:

1. Kompilierzeit-Polymorphismus (Methodenüberladung - Overloading) → Siehe Kapitel 9
2. Laufzeit-Polymorphismus (Methodenüberschreibung - Overriding) → Hier!

📋 Beispiel: Laufzeit-Polymorphismus

class Tier {
    void stimulus() {
        System.out.println("Tier macht Geräusch.");
    }
}

class Hund extends Tier {
    @Override
    void stimulus() {
        System.out.println("Hund bellt: Wuff!");
    }
}

class Katze extends Tier {
    @Override
    void stimulus() {
        System.out.println("Katze miaut: Miau!");
    }
}

public class PolymorphismusBeispiel {
    public static void main(String[] args) {
        // Polymorphismus: Tier-Referenz, aber Hund-Objekt!
        Tier meinTier1 = new Hund();
        Tier meinTier2 = new Katze();
        
        meinTier1.stimulus();  // Hund bellt: Wuff! (Laufzeit!)
        meinTier2.stimulus();  // Katze miaut: Miau! (Laufzeit!)
    }
}

→ Welche Methode aufgerufen wird, entscheidet sich zur Laufzeit (Dynamic Method Dispatch)!

📝 Zusammenfassung

In diesem Kapitel hast du gelernt:

• ✅ Kapselung (Encapsulation) = private + getter/setter
• ✅ Vererbung (Inheritance) = extends (Code-Wiederverwendung)
• ✅ Methodenüberschreibung (Overriding) = @Override
• ✅ super Schlüsselwort (Superklasse aufrufen)
• ✅ Polymorphismus (Polymorphism) = Viele Formen

💡 Merksatz für Anfänger

"Vererbung = extends (ist ein). Polymorphismus = Tier t = new Hund() (Laufzeit-Entscheidung)!"

🎯 Nächste Schritte

Im nächsten Kapitel lernst du:

• Häufige Schlüsselwörter (Kapitel 12)
• static statisches Schlüsselwort
• final Schlüsselwort
• Code-Blöcke (Static/Instance Initializer)
• Innere Klassen (Inner Classes)

Bereit für mehr? Los geht's! 🚀

---

📚 Weiterführende Links:

• Oracle Java Tutorials - Inheritance
• Java Polymorphism

💬 Fragen?
Hinterlassen Sie einen Kommentar!