1. 🏆 Dein Meisterstück: Alle 3 Lehrpfade vereint!

Herzlichen Glückwunsch zu diesem Meilenstein! Du hast gelernt, wie man Variablen deklariert, Schleifen baut, Klassen als Baupläne entwirft, Datenstrukturen serialisiert und echte Desktop-Fenster mit Tkinter zum Leben erweckt.

In diesem Master-Abschlussprojekt baust du eine vollwertige, professionelle Software für ein Tierheim: Den PetCare- & Tierheim-Manager. Hier greifen alle Rädchen nahtlos ineinander:

2. 🏛️ Die Architektur: Model-View-Controller (MVC)

In professionellen Software-Unternehmen schreibt man niemals Geschäftslogik und Benutzeroberfläche in einen einzigen großen Code-Klotz ("Spaghetti-Code"). Stattdessen trennt man das System strikt nach dem MVC-Muster:

3. 🧬 Das Datenmodell: Vererbung & Polymorphie

Ein Tierheim beherbergt verschiedene Tierarten: Hunde, Katzen und Vögel. Sie alle teilen gemeinsame Eigenschaften (Name, Alter, Gewicht, Impfstatus, Hunger), besitzen jedoch jeweils eigene Spezialmerkmale und Verhaltensweisen:

class Tier:
    def __init__(self, name: str, alter: int, gewicht: float, geimpft: bool = False, hunger: int = 50):
        if not name.strip():
            raise ValidierungsFehler("Name darf nicht leer sein!")
        self.name = name.strip()
        self.alter = alter
        self.gewicht = gewicht
        self.geimpft = geimpft
        self.hunger = max(0, min(100, hunger))

    def mache_laut(self) -> str:
        return f"{self.name} macht ein Geräusch."

class Hund(Tier):
    def __init__(self, name: str, alter: int, gewicht: float, rasse: str = "Mischling", ...):
        super().__init__(name, alter, gewicht, ...)
        self.rasse = rasse
        self.gassigegangen = False

    def mache_laut(self) -> str:
        return f"{self.name} bellt: Wuff! Wuff! 🐶"

4. 💾 Savegame-Persistenz mit dem Factory-Muster

Beim Speichern als JSON-Datei wandeln wir jedes Tier-Objekt in ein Dictionary um und ergänzen den Schlüssel "art": "Hund". Beim Laden liest die Factory-Methode Tier.from_dict(data) diesen Schlüssel aus und erzeugt automatisch die exakte Unterklasse:

@classmethod
def from_dict(cls, data: dict) -> Tier:
    art = data.get("art", "Tier")
    if art == "Hund":
        return Hund(name=data["name"], alter=data["alter"], gewicht=data["gewicht"], rasse=data.get("rasse", "Mischling"), ...)
    elif art == "Katze":
        return Katze(...)
    elif art == "Vogel":
        return Vogel(...)
    else:
        return Tier(...)

5. ✅ Deine Projekt-Checkliste

Arbeite die folgenden 5 Abschnitte in der Datei aufgabe.py der Reihe nach ab:

• 1. Eigene Exceptions: TierheimFehler, ValidierungsFehler, TierNichtGefundenFehler, KapazitaetUeberschrittenFehler.
• 2. Basisklasse Tier: Validierung von Name, Alter, Gewicht im __init__, Methoden fuettern(), impfen(), to_dict() und Factory-Methode from_dict().
• 3. Kindklassen Hund, Katze, Vogel: Vererbung mit super(), artspezifische Attribute & Methoden (gassi_gehen(), kratzen(), fliegen()) und polymorphes mache_laut().
• 4. Geschäftslogik Tierheim: Tieraufnahme mit Kapazitätsprüfung, Vermittlung/Entlassen, Filter nach Art/Impfung/Hunger, Statistiken (Ø Alter, Gewicht) und JSON-/CSV-Persistenz.
• 5. Benutzeroberfläche TierheimApp: Tkinter-Events mit dem Model verknüpfen, try-except Fehlerabfang und dynamische Statusleisten-Meldungen.

6. 💡 Ausklappbare Hilfestellungen & Tipps

class TierheimFehler(Exception):
    pass

class ValidierungsFehler(TierheimFehler):
    pass

with open(dateipfad, "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["Art", "Name", "Alter", "Gewicht", "Geimpft", "Hunger", "Details"])
    for t in self.tiere:
        writer.writerow([t.__class__.__name__, t.name, t.alter, f"{t.gewicht:.1f}", "Ja" if t.geimpft else "Nein", f"{t.hunger}%", t.get_details()])

try:
    self.tierheim.tier_aufnehmen(neues_tier)
    self.aktualisiere_ansicht()
    self.setze_status(f"{neues_tier.name} aufgenommen! 🎉", typ="success")
except TierheimFehler as e:
    self.setze_status(str(e), typ="warning")

7. 🧪 Lösung überprüfen & App starten

1. Automatische Unittests ausführen:

python3 test_aufgabe.py

2. Grafische Desktop-Applikation starten:

python3 app.py

🧠 Diagnostischer Selbst-Check

Überprüfe dein Verständnis der Kernkonzepte und typischen Denkfallen, bevor du den Code in der Web-IDE schreibst.