11 Objektorientierte Programmierung, Teil 2

Transkript

1 11 Objektorientierte Programmierung, Teil 2 Ein wesentliches Konzept der objektorientierten Programmierung fehlt uns noch: die Vererbung 203

2 Programmcode wiederverwenden Wenn wir einige Klassen geschrieben haben, werden wir dabei Teile davon öfters hingeschrieben haben. Das geht mit copy & paste zwar schnell, ist aber unschön: Das Programm wird unübersichtlich Wenn wir im gemeinsamen Teil was ändern wollen, wird s richtig ärgerlich Die Weitergabe an andere Leute ist auf diese Weise auch unelegant Wir brauchen einen Mechanismus der Sprache, der die Wiederverwendung unterstützt! Wenn wir eine neue Klasse Y schreiben, würden wir vielleicht gerne sagen: Die funktioniert wie Klasse X, mit folgenden Änderungen:... In dieser Allgemeinheit lässt die objektorientierte Programmierung das nicht zu, sondern nur in der Form der Spezialisierung: Y ist eine Ausprägung von X mit folgenden zusätzlichen Eigenschaften:... Wichtige Frage beim Entwurf: Kann ein Objekt der Klasse Y überall da auftreten, wo ein Objekt der Klasse X erwartet wird? 204

3 Vererbung Diese Spezialisierung nennt man Vererbung. Man sagt: Die Klasse Y erbt von der Klasse X X ist Oberklasse von Y Y ist Unterklasse von X (von X abgeleitet) Streng genommen: direkte Ober-/Unterklasse, weil X seinerseits Spezialisierung einer anderen Klasse sein kann, die dann auch Oberklasse von Y ist, aber keine direkte. Eine Klasse kann viele, auch direkte, Unterklassen haben; aber direkte Oberklasse wird sie bei uns nur eine haben (Python kennt auch mehrfache Vererbung, das wird aber schnell unübersichtlich). 205

4 Abstraktes Beispiel: algebraische Strukturen Ein Beispiel für eine Spezialisierungshierarchie: Halbgruppe, Monoid, Gruppe, Ring, Körper (letztere beiden bezüglich der Addition). Die Definition ging ja irgendwie so wie vorhin: Ein Y ist ein X mit folgenden weiteren Eigenschaften:... Überall, wo z.b. über eine Gruppe geredet wird, kann ich einen Ring (mit seiner Addition) einsetzen 206

5 Einfaches Beispiel in Python Nehmen wir einfach unsere Klasse Dauer von letzter Woche und spezialisieren sie zu einer Klasse zum Speichern von Zeitangaben in Stunden. Im Folgenden sei immer angenommen, dass die Klassendefinition von Dauer schon ausgeführt ist am einfachsten schreiben wir die neuen Definitionen zum alten Programm dazu. Wir erben von einer Klasse, indem wir in der class-definition der neuen Klasse die Oberklasse in den runden Klammern angeben (wir sehen: wir haben bereits geerbt, und zwar von einer Oberklasse object, die ganz allgemeine Fähigkeiten von Objekten bereitstellt die nehmen wir, wenn wir nicht von einer speziellen anderen Klasse erben wollen). Im einfachsten Fall müssen wir in die Definition der Unterklasse nichts weiter reinschreiben (naja, pass, weil Blöcke in Python nicht leer sein dürfen): class Stunden(Dauer): pass 207

6 Geerbte Attribute verwenden Bis hierher erfüllt die Klasse Stunden nur den Zweck, den Sachverhalt des Erbens zu studieren die Unterklasse erbt alle Attribute der Oberklasse, verhält sich also vorerst genau so: Objektmethoden, insbesondere den Konstruktor h1 = Stunden(2.0, h ) print h1.sekunden() Objektattribute: print h1.wert Klassenmethoden: Stunden.neue_einheit( d, Dauer(24, h )) (Nebenbei: man sieht hier, dass es Dauer sehr wohl noch gibt!) Klassenattribute: print Stunden.einheiten 208

7 Attribute hinzufügen und überschreiben Attribute, die wir in der Klasse Stunden hinzufügen (Objektmethoden, Klassenattribute und -methoden Objektattribute sind davon nicht direkt betroffen, sie stehen ja nicht in der Klassendefinition selbst), kommen einfach zu den geerbten Attributen hinzu. Ausnahme: bei einer Methodendefiniton gibt es schon eine Methode dieses Namens. In diesem Fall wird die bestehende Methode (aus der Definition von Dauer, ggf. auch aus der Definition von object) überschrieben. Es gilt: für alle Objekte der Unterklasse die neue Definition, Für alle Objekte der Oberklasse natürlich weiter die alte Definition. (Andere Attribute kann man auch überschreiben, aber die Regeln hierfür sind komplizierter.) 209

8 Also überschreiben wir was, z.b. den Konstruktor. Um erstmal zu zeigen, dass es prinzipiell geht, bringen wir eine ganz kleine Änderung an (sinnvollere Beispiele folgen... ) und ändern den Standardwert für die Einheit von s auf h : class Stunden(Dauer): def init (self, wert=0., einheit= h ): self.wert = float(wert) if einheit in self.einheiten: self.einheit = einheit else: raise ValueError( Unzulaessige Einheit: \ + einheit) Alten und neuen Konstruktor ausprobieren: >>> t1 = Dauer() >>> t2 = Stunden() >>> print t1, t2 0.0s 0.0h 210

9 Überschriebene Methoden verwenden Schon im Minibeispiel haben wir folgende typische Situation gesehen: Wir wollen die bisherige Funktion eigentlich nicht ganz wegwerfen, sondern nur ein wenig anpassen (und lieber keinen Programmcode kopieren). Dazu wäre es hilfreich, wenn wir die Methode der Oberklasse aufrufen könnten. Und das können wir in Python, indem wir sie als Funktion der Oberklasse (im Gegensatz zu: als Methode) verwenden, also über den Klassennamen und einschließlich des self-parameters bei den Aktualparametern: class Stunden(Dauer): def init (self, wert=0., einheit= h ): Dauer. init (self, wert, einheit) Nebenbei bemerkt: Das ist genau das, was Python normalerweise aus unseren Methodenaufrufen intern macht. Python bietet noch eine andere Möglichkeit mittels der Funktion super, bei der der Name der Oberklasse nicht aufgeführt werden muss: def init (self, wert=0., einheit= h ): super(stunden, self). init (wert, h ) 211

10 Beispiel: Funktionen Ein etwas größeres Beispiel bekommen wir, dem wir eine Klasse für Funktionen R R schreiben. Die wesentliche Methode einer Funktion f wird sein, zu einem x R den Funktionswert f (x) zu liefern. Wie der berechnet wird, wissen wir noch nicht, das kommt erst, wenn wir spezialisierte Unterklassen (z.b. für Polynome) bauen werden. Damit die Methode aber auf jeden Fall vorhanden ist, schreiben wir sie schon mal folgendermaßen hin: class Funktion(object): def wert(self, x): raise NotImplementedError() Es wird also wenig Sinn haben, Objekte der Klasse Funktion zu instanziieren das tun wir nur mit den Unterklassen. Wir können aber in der Klasse Funktion Methoden definieren, die dann automatisch Objekten von allen Unterklassen zur Verfügung stehen. 212

11 Z.B. eine Methode, die eine Wertetafel druckt (Wertebereich [a, b] in n gleichgroße Teilintervalle zerlegt): def tabelle(self, a, b, n): h = float(b-a)/n print x %s % str(self) print %s-- % ( - * len(str(self))) for i in range(0, n+1): print %10.4f %10.4f % (h*i, self.wert(h*i)) (zur Klassendefiniton von Funktion dazuschreiben). Man beachte insbesondere den Aufruf self.wert(h*i): hier wird die Methode des Objekts aufgerufen, die in der zugehörigen Unterklasse hoffentlich überschrieben ist (sonst gibt s an der Stelle einen NotImplementedError) 213

12 Es wird Zeit für eine Unterklasse, von der wir wirklich Objekte instanziieren können. Für Polynome können wir das einfach kopieren: class Polynom(Funktion): def init (self, koeff = []):... (wie gehabt, hier einfügen) def str (self):... (wie gehabt, hier einfügen) def wert(self, x):... (wie gehabt, hier einfügen) Nun geht z.b. folgendes: p = Polynom([3,2,1]) print p.wert(3) p.tabelle(0, 1, 10) 214

13 Schöner als p.wert(3) wäre eigentlich p(3). Das geht in Python, indem man die spezielle Methode call definiert. Dann ist ein Objekt ausführbar, d.h., es kann mit einer Parameterliste versehen werden (wie eben p(3)). Die Auswertung dieses Ausdrucks ist ein Aufruf der Methode call, die als Parameter außer dem Objektbezug einfach alle Parameter des Aufrufs bekommt. Also ergänzen wir die Methode (Funktion) um folgendes (die Unterklassen, z.b. Polynom, brauchen wir nicht zu ändern, die erben ja die neue Methode automatisch): def call (self, x): return self.wert(x) 215

14 Als nächstes lernen wir, Funktionen zu addieren. Da wir im Allgemeinen keine geschlossene Formel für die Summe angeben können (Funktionen als solche können ja nur ausgewertet werden), bauen wir eine Klasse, die die beiden Summanden speichert: class Summe(Funktion): def init (self, f, g): self.f = f self.g = g def str (self): return (%s) + (%s) % (str(self.f), str(self.g)) def wert(self, x): return self.f.wert(x) + self.g.wert(x) Damit geht folgendes: p = Polynom([3,2,1]) q = Polynom([1,2,3]) r = Summe(p,q) r.tabelle(0, 1, 10) 216

15 Schöner als r = Summe(p,q) wäre natürlich r = p + q. Das ist einfach: In der Klasse Funktion die Methode add ergänzen: def add (self, other): return Summe(self, other) Andere Programmiersprachen hätten hier ein Problem damit, dass wir nun bei der Definition von Funktion schon die Klasse Summe verwenden. In Python ist das egal die Definition von Summe kann irgendwann vor der ersten Verwendung von add passieren. 217

16 Noch schöner wäre nun, wenn bei der Addition von zwei Polynomen wieder ein Polynom rauskommt. Im Prinzip liegt die Lösung nahe: In der Klasse Polynom die Methode add überschreiben. Das Problem dabei ist, dass wir nicht wissen, ob other ein Polynom ist. Die Lösung dafür ist die Funktion isinstance(objekt, Klasse), die prüft, ob objekt Instanz von Klasse ist. So könnte nun die Addition in der Klasse Polynom aussehen: def add (self, other): if isinstance(other, Polynom):... Koeffizienten k berechnen (wie gehabt) return Polynom(k) else: return Funktion. add (self, other) Ausprobieren: mit Polynomen p und q sieht die Überschrift von (p+q).tabelle(0, 1, 10) viel schöner aus. 218

17 Selber machen! Mit den Klassen Funktion und Polynom ist noch eine Menge zu tun: Zum Warmlaufen kann man z.b. analog zur Addition die Multiplikation von Funktionen im Allgemeinen und von Polynomen im Speziellen einbauen. Dann kann man die Funktionen mit einer Methode zu numerischen Quadratur versehen. Die bekommt als Parameter die Intervallgrenzen a und b aus b a f (x) dx und eine Zahl n von Teilintervallen und liefert das z.b. mittels Trapezsumme approximierte Integral. Für die Polynome kann man diese Funktion dahingehend modifizieren, dass n auch weggelassen (oder z.b. auf 0 gesetzt) werden darf in diesem Fall soll der (bis auf Rundungsfehler durch die Darstellung in Fließkommazahlen) exakte Wert berechnet und zurückgeliefert werden. 219