{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Objektorientierung – Notebook\n",
    "\n",
    "**Informatik 12 · Objektorientierte Modellierung**\n",
    "\n",
    "Im Heft steht Objektorientierung in Delphi. Python macht dieselben Begriffe in\n",
    "weniger Zeilen sichtbar: Klasse, Objekt, Attribut, Konstruktor, Methode,\n",
    "Datenkapselung, Vererbung, Polymorphie.\n",
    "\n",
    "Die Begriffe sind dieselben, nur die Schreibweise ist kürzer. Wer beides einmal\n",
    "nebeneinander gesehen hat, verwechselt Sprache und Konzept nicht mehr.\n",
    "\n",
    "Führen Sie zuerst die nächste Zelle aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def zeile(*teile):\n",
    "    print(\"  \".join(str(t).ljust(16) for t in teile))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Aufgabe 1 · Eine Klasse mit Konstruktor\n",
    "\n",
    "Schreiben Sie die Klasse `Konto` mit den Attributen `inhaber` und `stand`. Der\n",
    "Konstruktor heißt in Python `__init__`; `self` entspricht dem `Self` in Delphi.\n",
    "\n",
    "Dazu zwei Methoden: `einzahlen(betrag)` als Auftrag und `anzeigen()` als Anfrage,\n",
    "die eine Zeichenkette zurückgibt.\n",
    "\n",
    "**Frage:** Was ist hier das Objekt, was die Klasse? Und wie viele Objekte entstehen, wenn Sie `Konto` dreimal aufrufen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Konto:\n",
    "    def __init__(self, inhaber, stand=0):\n",
    "        # TODO: Attribute setzen\n",
    "        pass\n",
    "\n",
    "    def einzahlen(self, betrag):\n",
    "        # TODO\n",
    "        pass\n",
    "\n",
    "    def anzeigen(self):\n",
    "        # TODO: z.B. \"Mayer: 250 Euro\"\n",
    "        return \"\"\n",
    "\n",
    "\n",
    "# a = Konto(\"Mayer\")\n",
    "# a.einzahlen(250)\n",
    "# print(a.anzeigen())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Aufgabe 2 · Datenkapselung\n",
    "\n",
    "Bisher kann jeder `a.stand = 1000000` schreiben. Das widerspricht dem\n",
    "Geheimnisprinzip aus Abschnitt 2.4.\n",
    "\n",
    "Nennen Sie das Attribut `_stand` (das heißt in Python: bitte nicht von außen\n",
    "anfassen) und bieten Sie stattdessen `abheben(betrag)` an, das nur abhebt, wenn\n",
    "genug Geld da ist, und `True` oder `False` zurückgibt.\n",
    "\n",
    "**Frage:** Python *verbietet* den Zugriff auf `_stand` nicht, es bittet nur darum. Ist das ein Nachteil gegenüber `private` in Delphi? Begründen Sie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SicheresKonto:\n",
    "    def __init__(self, inhaber, stand=0):\n",
    "        self.inhaber = inhaber\n",
    "        self._stand = stand\n",
    "\n",
    "    def stand(self):\n",
    "        # TODO: Anfrage statt direktem Zugriff\n",
    "        return 0\n",
    "\n",
    "    def einzahlen(self, betrag):\n",
    "        # TODO: nur positive Betraege annehmen\n",
    "        pass\n",
    "\n",
    "    def abheben(self, betrag):\n",
    "        # TODO: True, wenn es geklappt hat, sonst False\n",
    "        return False\n",
    "\n",
    "\n",
    "# b = SicheresKonto(\"Mayer\", 100)\n",
    "# print(b.abheben(50), b.stand())\n",
    "# print(b.abheben(500), b.stand())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Aufgabe 3 · Vererbung\n",
    "\n",
    "`Sparkonto` ist ein `SicheresKonto` mit Zinssatz. Es erbt alles und ergänzt\n",
    "`zinsen_gutschreiben()`.\n",
    "\n",
    "Überschreiben Sie außerdem `abheben` so, dass höchstens 2000 Euro auf einmal\n",
    "abgehoben werden dürfen.\n",
    "\n",
    "**Frage:** Rufen Sie im überschriebenen `abheben` die Fassung der Oberklasse mit `super().abheben(...)` auf. Warum ist das besser, als die Prüfung noch einmal hinzuschreiben?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Sparkonto(SicheresKonto):\n",
    "    def __init__(self, inhaber, stand=0, zinssatz=0.02):\n",
    "        # TODO: Konstruktor der Oberklasse aufrufen, Zinssatz merken\n",
    "        pass\n",
    "\n",
    "    def zinsen_gutschreiben(self):\n",
    "        # TODO\n",
    "        pass\n",
    "\n",
    "    def abheben(self, betrag):\n",
    "        # TODO: hoechstens 2000, sonst an die Oberklasse weitergeben\n",
    "        return False\n",
    "\n",
    "\n",
    "# s = Sparkonto(\"Weber\", 5000)\n",
    "# s.zinsen_gutschreiben()\n",
    "# print(s.stand(), s.abheben(3000), s.abheben(1000), s.stand())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Aufgabe 4 · Polymorphie\n",
    "\n",
    "Legen Sie eine Liste mit einem `SicheresKonto` und zwei `Sparkonto`-Objekten an\n",
    "und rufen Sie in einer Schleife auf jedem `abheben(2500)` auf.\n",
    "\n",
    "Geben Sie zu jedem Objekt aus, welche Klasse es hat (`type(objekt).__name__`) und\n",
    "was `abheben` geliefert hat.\n",
    "\n",
    "**Frage:** Dieselbe Zeile Code, zwei verschiedene Verhalten. In Delphi braucht es dafür `virtual` und `override` — in Python nicht. Was macht Python stattdessen, und wann fällt der Unterschied auf?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Liste anlegen, Schleife, Ausgabe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Aufgabe 5 · Objekte, die Objekte kennen\n",
    "\n",
    "Schreiben Sie `Bank` mit einer Liste von Konten, `aufnehmen(konto)`,\n",
    "`gesamtvermoegen()` und `finde(inhaber)`.\n",
    "\n",
    "Das ist genau das Message-Passing aus Abschnitt 2.1: Die Bank rechnet nicht selbst\n",
    "in fremden Attributen, sondern fragt jedes Konto nach seinem Stand.\n",
    "\n",
    "**Frage:** Warum darf `gesamtvermoegen` nicht `konto._stand` lesen? Was würde kaputtgehen, wenn Sie den Kontostand später in Cent statt in Euro speichern?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Bank:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.konten = []\n",
    "\n",
    "    def aufnehmen(self, konto):\n",
    "        # TODO\n",
    "        pass\n",
    "\n",
    "    def gesamtvermoegen(self):\n",
    "        # TODO\n",
    "        return 0\n",
    "\n",
    "    def finde(self, inhaber):\n",
    "        # TODO: Konto oder None\n",
    "        return None\n",
    "\n",
    "\n",
    "# bank = Bank(\"Sparkasse\")\n",
    "# for konto in konten:\n",
    "#     bank.aufnehmen(konto)\n",
    "# print(bank.gesamtvermoegen(), bank.finde(\"Weber\").stand(), bank.finde(\"Nix\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Abgabe\n",
    "\n",
    "Fertig ist das Notebook, wenn es durchläuft und `Sparkonto` bei 3000 Euro ablehnt,\n",
    "bei 1000 Euro aber auszahlt.\n",
    "\n",
    "Zeichnen Sie zum Schluss das UML-Klassendiagramm zu Ihren vier Klassen — auf Papier\n",
    "oder als Text in einer Markdown-Zelle. Vergessen Sie die Pfeile nicht."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
