OOP-6.6 6 Jenseits von Java 6.1 Variationen von Inheritance 6.1.1 Konkatenation oder Delegation Betrifft Implementierung von Objektspeicher und Methodenbindung Konkatenation: Delegation: Objektspeicher: Objektspeicher: zusammenhängender Speicher mit Speicherblock für das Objekt und Anteilen für die Klasse und jede Oberklasse Referenzen auf die Elternobjekte A-Objekt A Anteil A B Anteil B B-Objekt C Anteil C C-Objekt Methodensuche: Methodensuche: wird für C-Objekt vollständig erledigt Aufrufe werden in einem Objekt erledigt oder an Oberobjekt delegiert Sprachen: C++, Eiffel, Simula, Beta Sprachen: Smalltalk, Self (c) 2013 bei Prof. Dr. Uwe Kastens -------------------------------------------------------------------------------- Vorlesung Objektorientierte Programmierung WS 2013/2014 / Folie 606 Ziele: Implementierung von Objekten in der Vorlesung: Erläuterungen dazu * Alternativen der Speicherstruktur * Alternativen der Methodensuche -------------------------------------------------------------------------------- OOP - 6.7 6.1.2 Multiple Inheritance Single Inheritance (Einfachvererbung): Jede Klasse hat höchstens oder genau eine direkte Oberklasse (Base Class). Inheritance-Relation ist linear aus Sicht einer Unterklasse; Inheritance-Relation ist ein Wald bzw. Baum für alle Klassen zusammen. Sprachen: Smalltalk, Java (für Klassen, nicht für Interfaces). Multiple Inheritance (Mehrfachvererbung): Jede Klasse hat beliebig viele direkte Oberklassen Inheritance-Relation ist DAG (aus Sicht einer Klasse und insgesamt) Sprachen: C++, Eiffel, CLOS Java's Inheritance und Interfaces können in C++ mit Multiple Inheritance und rein abstrakten Klassen nachgebildet werden. C++ ermöglicht Übergang von Interfaces zu Klassen. Namensproblem: gleicher Name in verschiedenen Klassen erreichbar A B C++: undifferenzierter Zugriff m statt A::m ist Fehler m m Eiffel: Erben ohne Umbenennung ist Fehler C CLOS: Kanten sind geordnet, erster Weg zu m gilt m() (c) 2013 bei Prof. Dr. Uwe Kastens -------------------------------------------------------------------------------- Vorlesung Objektorientierte Programmierung WS 2013/2014 / Folie 607 Ziele: Begriff verstehen in der Vorlesung: Erläuterungen * zu SI, MI-Strukturen: linear, Baum, Wald, DAG * zur Rolle von Interfaces * zum Namensproblem -------------------------------------------------------------------------------- OOP - 6.8 Mehrfach vorkommende Oberklasse Eine Klasse L kann mehrfach indirekte Oberklasse einer Klasse C sein. C++: zwei Varianten: Konkatenation L L L-Anteil v. A. A-Anteil A-Anteil L B-Anteil A B L-Anteil v. B A B C-Anteil B-Anteil C C-Anteil C L-Anteil class A: public L {...} class A: public virtual L {...} class B: public L {...} class B: public virtual L {...} Objekte enthalten L-Anteile mehrfach Objekte enthalten L-Anteil nur einmal; A und B benutzen L unabhängig L hat gemeinsame Daten für die Unterklassen (Attribute und Methoden) C muss differenzieren Eiffel: nur diese Variante mit expliziter Selektion (c) 2005 bei Prof. Dr. Uwe Kastens -------------------------------------------------------------------------------- Vorlesung Objektorientierte Programmierung WS 2013/2014 / Folie 608 Ziele: Varianten verstehen in der Vorlesung: * Erläuterung der Varianten * Hier fehlt ein gutes Beispiel für überzeugenden Einsatz von Multiple Inheritance. * Hypothese: MI ist eine Implementierungstechnik, um höhere Konzepte wie "Rollen, Schnittstellen, Mixins" zu realisieren. Verständnisfragen: Gesucht ist ein überzeugendes Beispiel für den Einsatz von Multiple Inheritance. -------------------------------------------------------------------------------- OOP - 6.9 6.1.3 Selektives Erben in Eiffel Einzelne Methoden und Datenattribute der Oberklasse können beim Erben explizit überschrieben, umbenannt, gelöscht class FIXED_TREE[T] inherit werden: TREE[T] redefine * Überschreiben (redefine) attach_to_higher, higher wird explizit gemacht! end; * Umbenennen (rename), CELL[T]; z. B. um Namenskonflikte zu vermeiden; ermöglicht auch, dieselbe Klasse direkt LIST [like Current] mehrfach zu erben rename Problem: Ersetzbarkeit, Subtyping werden off as child_off, ... zerstört! redefine duplicate, first_child * Löschen - nicht erben end undefine f end; Problem: Ersetzbarkeit, Subtyping werden feature zerstört! .... * Für bestimmte Klassen zugreifbar end; machen export {A,B} f; ANY g; end (c) 2013 bei Prof. Dr. Uwe Kastens -------------------------------------------------------------------------------- Vorlesung Objektorientierte Programmierung WS 2013/2014 / Folie 609 Ziele: Sprachkonstrukte kennenlernen in der Vorlesung: * Erläuterungen zur Bedeutung der Konstrukte, * Diskussion der Möglichkeiten und Konsequenzen -------------------------------------------------------------------------------- OOP - 6.9a Weitere Eigenschaften von Eiffel * Generische Definitionen class FIXED_TREE[T] inherit TREE[T] * Multiple inheritance: redefine FIXED_TREE[T] erbt von attach_to_higher, higher TREE[T], CELL[T], LIST[...] end; * Current entspricht this o. self CELL[T]; * like X: steht für den Typ von X, LIST [like Current] z.B. einsetzbar zur Lösung des Problems rename der binären Operationen: off as child_off, ... Eine Methode plus in der Klasse A sei redefine deklariert als duplicate, first_child like Current plus (like Current).. end dann hat sie in A die Signatur feature plus: A x A -> A .... In einer Unterklasse B wird sie mit der end; Signatur geerbt plus: B x B -> B (c) 2013 bei Prof. Dr. Uwe Kastens -------------------------------------------------------------------------------- Vorlesung Objektorientierte Programmierung WS 2013/2014 / Folie 609a Ziele: Sprachkonstrukte kennenlernen in der Vorlesung: * Erläuterungen zur Bedeutung der Konstrukte, * Diskussion der Möglichkeiten und Konsequenzen -------------------------------------------------------------------------------- OOP - 6.10 6.1.4 Mixin Inheritance Mixin: Wiederverwendbare Zusammenfassung weniger Methoden und Datenattribute für bestimmten Zweck. Mixins liegen außerhalb der Klassenhierarchie, werden von Klassen geerbt. mixin Name class Person inherits Name,Adresse { String name; { .... } void setName (String n){.... } string getName () {.... } class Firma inherits Adresse } { .... } mixin Adresse {.... } Nicht explizit als Konstrukt in verbreiteten Sprachen. Kann mit Mehrfachvererbung implementiert werden (z. B. in C++, Eiffel). (c) 2014 bei Prof. Dr. Uwe Kastens -------------------------------------------------------------------------------- Vorlesung Objektorientierte Programmierung WS 2013/2014 / Folie 610 Ziele: Mixin-Konzept verstehen in der Vorlesung: Erläuterungen zum Konzept * Kleine, wiederverwendbare Komponenten, * implementierte Rollen, * implementierte Eigenschaften -------------------------------------------------------------------------------- OOP - 6.11 6.2 Varianten der dynamischen Methodenbindung Richtung der Methodensuche: aufwärts Die Entscheidung, welche von überschriebenen Methoden aufgerufen wird, kann als Suche entlang der Vererbungsrelation beschrieben werden: von der Klasse des Objekts A m(){..} aufwärts durch die Oberklassen ersetzt die überschreibende Methode die überschriebene vollständig überschreiben - ggf. mit anderer Bedeutung! B m(){..} Die Oberklasse kann sich dagegen nicht absichern. Sprachen: Java, C++ , Eiffel, Smalltalk suchen In Smalltalk ist die Suche so als Delegation implementiert. C In übersetzten Sprachen wird die Suche möglichst vermieden - durch Übersetzertabellen. C c = new C(); c.m() Wird auch American semantics genannt. (c) 2013 bei Prof. Dr. Uwe Kastens -------------------------------------------------------------------------------- Vorlesung Objektorientierte Programmierung WS 2013/2014 / Folie 611 Ziele: Methodensuche verstehen in der Vorlesung: Erläuterung der Methodensuche in beiden Richtungen -------------------------------------------------------------------------------- OOP - 6.11a Richtung der Methodensuche: abwärts Die Entscheidung, welche Methoden aufgerufen werden, kann als Suche entlang der suchen Vererbungsrelation beschrieben werden: Von der höchsten Oberklasse abwärts zur Klasse A m(){... inner ...} des Objektes werden alle Methoden gleichen Namens und passender Signatur ausgeführt. aufrufen Im Rumpf der Methode kann durch inner speziali- gekennzeichnet werden, wo die Ausführung "tieferer" sieren Methoden eingebettet wird. B m(){..} Die Oberklasse kann so Erweiterungsstellen definieren. Die Methoden werden so in Unterklassen spezialisiert statt ersetzt. C Sprachen: Beta, Simula. Wird auch Scandinavian semantics genannt. C c = new C(); c.m() (c) 2013 bei Prof. Dr. Uwe Kastens -------------------------------------------------------------------------------- Vorlesung Objektorientierte Programmierung WS 2013/2014 / Folie 611a Ziele: Methodensuche verstehen in der Vorlesung: Erläuterung der Methodensuche in beiden Richtungen -------------------------------------------------------------------------------- OOP - 6.12 Mehrfach-Dispatch Einfach-Dispatch: Methodenaufruf wird auf ein Objekt angewandt (Receiver): a.plus (b) Die Klassenzugehörigkeit des Objektes in a bestimmt, welche Methode aufgerufen wird. Die Parameterobjekte tragen nicht zu der Entscheidung bei. Auch konzeptionell symmetrische Operationen werden unsymmetrisch ausgeführt. Sprachen: fast alle objektorientierten Sprachen Mehrfach-Dispatch: Die Klassenzugehörigkeiten aller Parameterobjekte zusammen plus (a, b) bestimmen, welche Methode aufgerufen wird. Symmetrische Behandlung der Parameter; kein hervorgehobener Receiver; z. B. plus für int, float und Vector unterschieden anhand der Objekte in a und b. Sprachen: CLOS, Lisp-Derivate (c) 2005 bei Prof. Dr. Uwe Kastens -------------------------------------------------------------------------------- Vorlesung Objektorientierte Programmierung WS 2013/2014 / Folie 612 Ziele: Mehrfach-Dispatch verstehen in der Vorlesung: Gegenüberstellung von Einfach- und Mehrfach-Dispatch -------------------------------------------------------------------------------- OOP-6.13 6.3 Prototyp-basierte Sprachen Klassen-basierte Sprachen (die meisten OO-Sprachen): Klasse Objekt Klasse: Objekt: * Programmelement * zur Laufzeit erzeugt * Plan zur Herstellung von * Exemplar einer Klasse Objekten * speichert individuelle * vereinigt statische Daten, Zustand instanziieren Eigenschaften der Objekte erben * Vererbung zwischen Klassen Prototyp-basierte Sprachen (Self, JavaScript): Es gibt keine Klassen - nur Objekte. Objekte werden Objekt Objekt * neu hergestellt oder * aus Prototyp-Objekten kopiert (geklont) und * individuell modifiziert, weiterentwickelt * Vererbung zwischen Objekten klonen und modifizieren (c) 2013 bei Prof. Dr. Uwe Kastens -------------------------------------------------------------------------------- Vorlesung Objektorientierte Programmierung WS 2013/2014 / Folie 613 Ziele: Gegenüberstellung in der Vorlesung: * Rolle der Klassen * Rolle der Objekte in Prototyp-basierten Sprachen * Erben von Objekten nachlesen: D. Ungar, R. B. Smith: SELF: The power of Simplicity, OOPSLA'87 Conference Proceedings, ACM SIGPLAN NOtices, Vol. 22(12), pp. 227-241, 1987 -------------------------------------------------------------------------------- OOP-6.14 JavaScript: Objektorientierte Scriptsprache Scriptsprache: * Sprache zum Aufruf von Programmen, ursprünglich Betriebssystem Kommandosprache, z. B. Unix Shell ähnlich: Perl, PHP, Python Beispiel mit JavaScript * interpretiert JavaScript:
* Scriptsprache zur Programmierung * von Netscape entwickelt
* in Browser integriert * kein Bezug zu Java * objektorientiert, Prototyp-basiert * in HTML (u.a.) integriert (c) 2013 bei Prof. Dr. Uwe Kastens -------------------------------------------------------------------------------- Vorlesung Objektorientierte Programmierung WS 2013/2014 / Folie 614 Ziele: Eindruck von JavaScript als Scriptsprache in der Vorlesung: * Charakterisierung von Scriptsprachen * Charakterisierung von JavaScript * Einbettung in HTML am Beispiel: * geklammert durch script- und Kommentarklammern * Aufruf einer Funktion des Programms im body-Teil. nachlesen: http://www.teamone.de/selfhtml/te.htm -------------------------------------------------------------------------------- OOP-6.15 Objekterzeugung Objekte werden durch Konstruktorfunktionen erzeugt: * mit new aufgerufen, * Funktionsrumpf greift über this auf Datenattribute zu * Datenattribute werden durch Zuweisung eingeführt function Farbe (Farbwert_R, Farbwert_G, Farbwert_B) { this.Farbwert_R = Farbwert_R; this.Farbwert_G = Farbwert_G; this.Farbwert_B = Farbwert_B; } function TestObjekt() { Test = new Farbe("A2", "FF", "74"); alert("Der Rotwert meiner Farbe ist " + Test.Farbwert_R); } (c) 2005 bei Prof. Dr. Uwe Kastens -------------------------------------------------------------------------------- Vorlesung Objektorientierte Programmierung WS 2013/2014 / Folie 615 Ziele: Konstruktorfunktion verstehen in der Vorlesung: Erläuterungen dazu -------------------------------------------------------------------------------- OOP-6.16 Objekt aus Prototyp erzeugen Prototyp-Objekt der Konstruktorfunktion zuordnen. Alle erzeugten Objekte erben die Prototyp-Eigenschaften. Delegation: Ändern des Prototyps ändert alle Objekte dazu - auch existierende function Farbe (Farbwert_R, Farbwert_G, Farbwert_B) { this.Farbwert_R = Farbwert_R; R this.Farbwert_G = Farbwert_G; this.Farbwert_B = Farbwert_B; G } B Rot = new Farbe("FF", "00", "00"); function FarbeMitNamen(Name) prototype { this.Name = Name;} FarbeMitNamen.prototype = Rot; Name Rot function TestObjekt() { Test = new FarbeMitNamen("Rot"); ... alert("Der Rotwert meiner Farbe ist " + Test.Farbwert_R + Name ". Der Name ist " + Test.Name); } (c) 2005 bei Prof. Dr. Uwe Kastens -------------------------------------------------------------------------------- Vorlesung Objektorientierte Programmierung WS 2013/2014 / Folie 616 Ziele: Prototyp-Zuordnung verstehen in der Vorlesung: Erläuterungen dazu. * Prototyp zur Konstruktorfunktion und zu erzeugten Objekten * Änderungen am Prototyp -------------------------------------------------------------------------------- OOP-6.17 Objekt-Hierarchie Objekt-Hierarchie aus Prototypen; dynamische Zuordnung von Methoden: Methode fig = new function(){}(); // leeres Objekt erzeugen zuweisen fig.move = function (dx, dy) // lambda-Ausdruck Konstruktor- { this.x += dx; this.y += dy}; Funktionen mit fig als Prototyp function Kreis(r) { this.x = 0; this.y = 0; this.radius = r;} dynamische Kreis.prototype = fig; Bindung für Namen von function Rechteck(l, b) Attributen und { this.x = 0; this.y = 0; this.lg = l; this.br = b;} Methoden Rechteck.prototype = fig; veränderlicher function TestObjekt() Zustand im { k1 = new Kreis(1); k1.move(5, 5); gemeinsamen r1 = new Rechteck(3,7); r1.move(2,4); Prototyp fig.printKoord = Überschreiben: function () Suche entlang der { alert( "x = "+ this.x + " y = " + this.y);} Prototyp- Referenzen k1.printKoord(); r1.printKoord(); } (c) 2013 bei Prof. Dr. Uwe Kastens -------------------------------------------------------------------------------- Vorlesung Objektorientierte Programmierung WS 2013/2014 / Folie 617 Ziele: Hierarchie und Methodenzuordnung kennenlernen in der Vorlesung: Erläuterungen * zur Objekthierarchie, * zur Schreibweise von Funktionen als Werte, * zur dynamischen Zuordnung von Methoden, * zur dynamischen Bindung von Bezeichnern -------------------------------------------------------------------------------- OOP-6.18 Prototypen gegenüber Klassen positiv für Prototypen: * Prototypen sind konkreter, näher an Objekten als Klassen es sind. * Einzige Objekte einer Art sind einfacher herzustellen. * Einfache, freizügig verwendbare Sprachkonzepte * Wenn Klassen "first class" sind braucht man Meta-Klassen und dafür Meta-Klassen ... negativ für Prototypen: * Konstruktorfunktionen sind ein halber Schritt in Richtung Klassen. * Individuelle Objektzustände können nicht im gemeinsamen Prototyp gespeichert werden; Abstraktion wird inkonsequent * keine Typsicherheit (bezüglich Klassen) * schwächere Möglichkeiten zur Abstraktion * zur Modellierung nicht geeignet (Ebene dert Klassen und Typen fehlt) (c) 2013 bei Prof. Dr. Uwe Kastens -------------------------------------------------------------------------------- Vorlesung Objektorientierte Programmierung WS 2013/2014 / Folie 618 Ziele: Argumente in der Vorlesung: Diskussion der Argumente --------------------------------------------------------------------------------