INF-OOP - Programmierparadigmen und Objektorientierung

Quadrate aller geraden Zahlen einer Liste `[1, 2, 3, 4, 5, 6]`.

1. 01Imperativ

   ```python ergebnis = [] for n in [1,2,3,4,5,6]: if n % 2 == 0: ergebnis.append(n*n) ```

2. 02Funktional / Comprehension

   ```python ergebnis = [n*n for n in [1,2,3,4,5,6] if n % 2 == 0] ```

3. 03Funktional / map+filter

   ```python ergebnis = list(map(lambda n: n*n, filter(lambda n: n%2==0, [1,2,3,4,5,6]))) ```

Ergebnis: Alle drei liefern $[4, 16, 36]$. Comprehension ist in Python idiomatisch; map/filter ist eher Lisp-Stil.

Implementiere `Konto` mit Saldo und `Sparkonto(Konto)` mit Zinssatz in Python.

1. 01Basisklasse

   ```python class Konto: def __init__(self, inhaber, saldo=0): self.inhaber = inhaber self._saldo = saldo def einzahlen(self, betrag): if betrag <= 0: raise ValueError("Betrag positiv") self._saldo += betrag def auszahlen(self, betrag): if betrag > self._saldo: raise ValueError("Deckung fehlt") self._saldo -= betrag @property def saldo(self): return self._saldo ```

2. 02Vererbung

   ```python class Sparkonto(Konto): def __init__(self, inhaber, saldo=0, zinssatz=0.02): super().__init__(inhaber, saldo) self.zinssatz = zinssatz def gutschreiben_zinsen(self): self._saldo *= (1 + self.zinssatz) ```

3. 03Anwendung

   ```python s = Sparkonto("Maria", 1000, 0.03) s.einzahlen(500) s.gutschreiben_zinsen() print(s.saldo) # 1545.0 ```

Ergebnis: Sparkonto erbt Saldo und Methoden, ergänzt zinsabhängige Logik. Encapsulation via `_saldo` (Konvention "protected") und Property.

Implementiere Subject und Observer.

1. 01Subject

   ```python class Subject: def __init__(self): self._obs = [] def attach(self, o): self._obs.append(o) def detach(self, o): self._obs.remove(o) def notify(self, ev): for o in self._obs: o.update(ev) ```

2. 02Observer

   ```python class MailObserver: def update(self, ev): print("Mail:", ev) ```

3. 03Nutzung

   ```python s = Subject() s.attach(MailObserver()) s.notify("Neuer Kommentar") ```

Ergebnis: Subject kennt seine Observer abstrakt; neue Observer-Klassen lassen sich ohne Änderung am Subject hinzufügen (Open/Closed).