Objektorientierte Programmiersprachen (in Arbeit)

Präsentation zum Thema: "Objektorientierte Programmiersprachen (in Arbeit)"—  Präsentation transkript:

1 Objektorientierte Programmiersprachen (in Arbeit)
© Günter Riedewald Die Folien sind eine Ergänzung zur Vorlesung und nur für den internen Gebrauch konzipiert.

2 Literatur Abadi, Martin, Cardelli, Luca: A Theory of Objects
Springer, 1996 Bruce, K. B.:Foundations of Object-Oriented Programming Languages: Types and Semantics The MIT Press, 2002 Budd, Timothy: An Introduction to Object-Oriented Programming Addison-Wesley, 2002 Brügge, B., Dutoit, A. H.: Objektorientierte Softwaretechnik mit UML, Entwurfsmustern und Java Pearson Studium, 2004

3 Poetzsch-Heffter, Arnd: Konzepte objektorientierter Programmierung Springer, 2000

4 Diverse Literatur zu objektorientierten Sprachen, z.B.:
Bishop, Judith: Java lernen Addison-Wesley, 2001 Deitel, H. M., Deitel, P. J.: C++ How to Program Prentice Hall, 1994 Goldberg, A., Robson, D.: Smalltalk-80: The Language Addison-Wesley, 1989 Gore, Jacob: Object Structures Building Object-Oriented Software Components with Eiffel Addison-Wesley, 1996

5 Kratzer, Klaus Peter: ADA Eine Einführung für Programmierer
Hanser, 1996 Lamprecht, G.: SIMULA – Einführung in die Programmiersprache Vieweg, 1988 Schiedermeier, R.: Programmieren mit Java Eine methodische Einführung Pearson Studium, 2005

6 Bücher über Konzepte von Programmiersprachen, z.B.:
Louden, Kenneth, C.: Programmiersprachen Grundlagen, Konzepte, Entwurf International Thomson Publishing, 1994

7 Objektorientierte Prototypsprachen
Blaschek, Günther: Object-Oriented Programming with Prototypes Springer, 1994 Entwurfsmuster in OOPS Gamma, E., Helm, R., Johnson, R., Vlissides, J.: Design Pattern: Elements of Reusable Object-Oriented Software Addison-Wesley, 1995

8 Beispiel: BEGIN CLASS liste; BEGIN INTEGER wert; REF(liste) nachf; END; REF(liste) l; l :- NEW liste; l.wert := 1; l.nachf :- NEW liste; l.nachf.wert := l.wert + 1; END

9 Beispiel: komplexe Zahlen in Simula
 CLASS Complex(x,y); REAL x,y; BEGIN REAL re,im; REAL PROCEDURE realpart; realpart := re; END realpart; REAL PROCEDURE imaginarypart; imaginarypart := im; END imaginarypart; PROCEDURE add(y); REF(Complex) y; re := re + y.realpart; im := im + y.imaginarypart; END add; ... comment – Initialisierungscode; re := x; im := y; END Complex;

10 Wurzel eines Teilbaumes: Operationssymbol (codiert)
Beispiel: abstrakte Syntaxbäume arithmetischer Ausdrücke (Kantorovič-Bäume) Wurzel eines Teilbaumes: Operationssymbol (codiert) Blätter eines Teilbaums: Operanden (Konstante, Variable, Teilbaum)  CLASS form; BEGIN END; form CLASS const(val); REAL val; BEGIN END; form CLASS var(nam, val); TEXT nam; REAL val; BEGIN END; form CLASS triple(lop, op, rop); REF(form) lop, rop; INTEGER op; BEGIN END;

11 REF(form) f, g, h; f :- NEW const(10); g :- NEW var(´g´, 9); h :- NEW triple(NEW triple(f, plus, g), plus, f); Liefert + + 10 g

12 Beispiel als Verbund (Record)
10.0  f lop op plus plus rop nam ´g´  g val 9.0

13 Vereinigung von Verbunden mit nichtleerer Oberklasse - Beispiel
CLASS klasse(a,b); REAL a, b; BEGIN REAL x, y; ... END; klasse CLASS klasse1(c, d); REAL c, d; BEGIN REAL u, v; u := c + d; v := x + y; END;

14 Definitionsschachtel für NEW klasse1(1, 2, 3, 4)
b 2.0 x w1 y w2 c 3.0 d 4.0 u 7.0 v w1+w2

15 Klassendefinition circle
CLASS circle(center, radius); REF(point) center; REAL radius; BEGIN REAL PROCEDURE area; area := pi * radius * radius; END area; … END circle; Klassendefinition rectangle CLASS rectangle(center, width, height); REF(point) center; REAL width, height; area := width * height; END rectangle;

16 Oberklasse closedFigure
CLASS closedFigure(center); REF(point) center; VIRTUAL: REAL PROCEDURE area; BEGIN … END closedFigure;

17 Neudefinition von circle closedFigure CLASS circle(radius);
closedFigure CLASS circle(radius); REAL radius; BEGIN REAL PROCEDURE area; area := pi * radius * radius; END area; … END circle; Neudefinition von rectangle closedFigure CLASS rectangle(width, height); REAL width, height; BEGIN REAL PROCEDURE area; area := width * height; END area; … END rectangle;

18 Programmstück REF(point) x,y; REF(closedFigure) f; REF(rectangle) s; REF(circle) c; x :- NEW point(0.0,0.0); y :- NEW point(1.0,-1.0); s :- NEW rectangle(x,1.0,1.0); c :- NEW circle(y,1.0); f :-s; f.area; f :-c;

19 Allgemeine Beziehungen zwischen Objekten
Ein Objekt X benutzt ein Objekt Y, wenn eine Methode von X eine Nachricht an Y schickt: mX: ...Y.n ... Eine Methode von X das Objekt Y a) erzeugt: mX: ...GY (Generator G) b) als Parameter übergeben bekommt: X.mX(Y...) c) als Ergebnis zurückgibt: mX: ... return Y

20 Hat-ein-Beziehung: Ein Objekt X hat ein Attribut, das das Objekt Y oder eine Referenz darauf als Wert hat. Teil-von-Beziehung: Spezialfall der Hat-ein-Beziehung, wobei Y als Teil von X betrachtet wird. Erreichbarkeitsbeziehung: transitive Hülle der Hat-ein- Beziehung Ist-ein-Beziehung: Jedes Objekt o einer Klasse U ist gleichzeitig Objekt einer Oberklasse zu u.

21 Beispiel: Personenstruktur an der Uni
Studenten: Name, Geburtsdatum, Adresse, Immatrikulationsdatum, Immatrikulationsnummer, Fachbereich, Studiengang, Fachsemester, wahrscheinliches Abschlussdatum Wissenschaftliche Mitarbeiter: Name, Geburtsdatum, Adresse, Einstellungsdatum, Beschäftigungsnummer, befristet/unbefristet, wahrscheinliches Beschäftigungsende, Fachbereich Nichtwissenschaftliche Mitarbeiter: Name, Geburtsdatum, Adresse, Einstellungsdatum, Beschäftigungsnummer, Fachbereich Hochschullehrer: Name, Geburtsdatum, Adresse, Berufungsdatum, Beschäftigungsnummer, Kategorie, Fachbereich

22 Person Name, Geburtsdatum, Adresse, Beschäftigungsbeginn, FB
Student Angestellte + Imm.-Nr., Studiengang, + Beschäftigungsnr. Fachsemester, wahrsch. Abschlußdatum Wissen. Mitarbeiter Nichtwiss. Mit. HSL + Befristung, wahr Kategorie Beschäftigungsende

23 Polymorphismus Einteilung nach Stansifer: Überladung ad hoc
implizite Umwandlung Polymorphismus Untertyp universell parametrisiert

24 Polymorphismus nach Programmiersprachen:
Nichtobjektorientiert: - Überladene Operatoren: gleicher Name, unterschiedliche Operation - Polymorphe Operatoren: gleicher Name, gleiche Operation auf unterschiedlichen Datentypen - Implizite Umwandlung: automatische Typkonvertierung von Operanden gemäß syntaktischer Position

25 - Einschließender Polymorphismus: Operation für gegebenen Typ schließt auch Daten eines abgeleiteten Typs ein - Parametrischer Polymorphismus: Operation für unterschiedliche Datentypen mit Typparameter 2. Objektorientiert - Gleiche Nachricht an Objekte unterschiedlicher Klassen löst unterschiedliche Operationen aus - Gleicher Variabler können Objekte unterschiedlicher Typen eines „Vererbungspfades“ zugewiesen werden  unterschiedliche Operationen bei gleicher Nachricht (dynamisches Binden)

26 Erscheinungsformen in OOPS:
Ad hoc: a) Gleicher Name für Methoden in voneinander unabhängigen Klassen A B m m a b a.m b.m

27 b) Gleicher Name für zwei unterschiedliche Methoden in gleicher Klasse (mit unterschiedlicher Signatur) c) Überschriebene geerbte Operation (Konkretisierung bei Übergang von abstrakter zu konkreter Klasse, Verfeinerung, völlig neue Implementation) Einschließender Polymorphismus (Vererbungspolymorphismus): Eine in einer Oberklasse definierte Methode wird auch auf die Objekte der abgeleiteten Klassen angewendet. Typparameter in generischen Einheiten

28 Statisches und dynamisches Binden Kovarianz und Kontravarianz
Hier: Zuordnung von Methoden (Operationen) zu Methodennamen (Operationssymbolen) Statisches Binden: Binden zur Übersetzungszeit Dynamisches Binden: Binden zur Laufzeit

29 Beispiel: Kovarianz, Kontravarianz
Tier TIER Ok OK F(Tier t) Katze KATZE HUND Hund Uk UK F(Katze t) Ok einObjekt = NEW Uk(...); Hund einHund = NEW Hund; einObjekt.F(einHund);

30 1. Fall: Statisches Binden: Da einObjekt vom Typ Ok ist (Vereinbarung), muss F aus der Klasse OK genommen werden. Daher ist der Parameter vom Typ Tier. Der aktuelle Parameter einHund ist vom Typ Hund und damit Untertyp von Tier. Dynamisches Binden: einObjekt referiert zur Laufzeit zu einem Objekt des Typs Uk (Klasse UK). Dynamisch wird deshalb F von UK mit dem formalen Parameter vom Typ Katze ausgewählt. Der Typ des aktuellen Parameters einHund ist aber Hund, welches kein Untertyp von Katze ist. Demzufolge wird ein Laufzeitfehler gemeldet.

31 2. Fall: Im Programmteil wird die erste Anweisung ausgetauscht gegen Ok einObjekt = NEW Ok(...);  Keine Differenz in den Sichten bei statischer und dynamischer Bindung

32 3. Fall: Änderung des 1. Falles: F in OK bekommt den Parametertyp Katze und F in UK den Parametertyp Tier Statisches Binden liefert einen Typfehler zur Übersetzungszeit (Auswahl von F aus Ok mit gefordertem Parametertyp Katze; Typ des aktuellen Parameters ist aber Hund). Dynamisches Binden ergibt keine Probleme (Auswahl von F aus Uk mit gefordertem Parametertyp Tier; Typ des aktuellen Parameters ist der Untertyp von Tier Hund).

33 Während bei den Klassen von der „größeren“ zur „kleineren“ Klasse übergegangen wird, geschieht das beim Parameter von F genau umgekehrt.  Kontravarianz Beispiel: OK Ok einObjekt = NEW Uk(...); Katze Ergebnis = einObjekt.g(...); Katze g(...) UK  Für Ergebnistypen von Methoden gilt bei dynamischer Bindung das Tier g(...) Prinzip der Kovarianz.

34 Smalltalk Grundprinzipien: Jedes Ding ist ein Objekt.
Jedes Objekt ist eine Instanz einer Klasse. Jede Klasse ist Unterklasse einer anderen Klasse. Jedes Objekt wird durch Nachrichten aktiviert. Klassen sind Objekte und damit Instanzen von Metaklassen. Festlegung von Object als oberste Klasse (Durchbrechung der unendlichen Definition)

35 Charakteristika von Smalltalk-Klassen:
Enthalten streng private Instanzvariablen (Speicherung des Objektzustands) Enthalten ein Nachrichtenprotokoll (Nachrichtenschnittstelle): Methoden zur Änderung oder zum Lesen des Objektzustands Enthalten Oberklasse Objekterzeugung durch new Objektzugriff über Zeiger

36 Beispiel: Definition der Klasse COMPLEX
Class name: COMPLEX Superclass: Object Instance variables: re im Methods : realPart  re imagPart  im setReal : x re  x setImag : y im  y + y  (COMPLEX new setReal : (re + (y realPart))) setImag: (im + (y imagPart)) ... x  (COMPLEX new setReal: 1.0) setImag: 1.0 y  (COMPLEX new setReal: 1.0) setImag: - 1.0 z  x + y

37 Klassenstruktur Boolean – True – False
ifTrue: ifFalse: xor: True False ifTrue: ifFalse: ifTrue: ifFalse: not not or: or: and: and: true false

38 Methodenidentifikation:
Vor.: Nachricht m an Objekt o der Klasse K a) Suche von m in K: Erfolg, wenn m gefunden wurde b) Fortsetzung der Suche in der Oberklasse: Erfolg, wenn m dort vorhanden ist Bei Misserfolg Fortsetzung in weiterer Oberklasse c) Suche erreicht Object und m ist nicht vorhanden: Nachricht DoesNotUnderstand: m an Objekt o und Identifikationsprozess mit DoesNotUnderstand d) Wird erneut Object erreicht, erfolgt eine Standardfehlermeldung

39 Beispiel: Fachbereichscodes Class name: Fachbereichscodes
Class name: Fachbereichscodes Superclass: Object Instance variables: names, codes Methods : ´´Create an instance´´ new  super new. ´´Create initial empty arrays´´ initialise [names  Array new: 0 codes  Array new: 0]. ´´Test for empty´´ isEmpty  names isEmpty. ´´Test for inclusion of a given name´´ include: name  (self indexOf: name) ~= 0.

40 ´´Create a new entry with the given name and return index´´
newIndexOf: name [self grow names at: names size put: name  names size]. ´´Stretch table by one element and put in new name´´ grow [oldNames oldCodes oldNames  names oldCodes  codes names  Array new: names size + 1 codes  Array new: codes size + 1 names replaceFrom: 1 to: oldNames size with: oldNames codes replaceFrom: 1 to: oldNames size with: oldCodes]. ´´Number of table entries´´ size  names size. ´´Fetch the code for a department´´ at: name [indexindex  self indexOf: name index = 0 ifTrue: [self error: ‘Error—Name not in table’] ifFalse: [ codes at: index]].

41 ´´Install a new code; create entry if necessary´´ at: name put: code
[index index  self indexOf: name index = 0 ifTrue: [index  self newIndexOf: name]  codes at: index put: code]. ´´Look-up index of a given department name´´ indexOf: name [1 to: names size do: [:index (names at: index) = name ifTrue: [ index]]  0]. ´´Ausdrücke´´ dCodes  Fachbereichscodes new erzeugt neue Instanz dCodes initialise initialisiert names und codes dCodes isEmpty names und codes sind leer dCodes at: ´Physics´ put: 100 Physics wird mit 100, dCodes at: ´Chemistry´ put: 110 Chemistry mit 110 und dCodes at: ´Biology´ put: 120 Biology mit 120 eingetragen dCodes isEmpty die Tabelle ist nicht leer dCodes size sie enthält 3 Eintragungen dCodes at: ´Chemistry´ liefert 110 dCodes includes ´Physics´ liefert true dCodes includes ´Computing´ liefert false

42 Object MetaClass Class ZClass Z AClass A erben von Metaklassen Klassen
Instanz sein von

43 Eiffel Charakteristische Prinzipien und Konstrukte:
Eiffel ist streng getypt: - Festlegung von Typen durch Deklaration - Statische Kompatibilität - Eindeutig bestimmbarer Typ Typen: - Referenztypen: Zeiger auf Objekte - Erweiterte Typen: Objekttypen - Basistypen: INTEGER, REAL, DOUBLE, CHARACTER, BOOLEAN

44 Klassen als Implementation von ADTs und Grundlage für Objekttypen
Klasse als Ding der Übersetzungszeit, Objekt als Ding der Laufzeit Vor- und Nachbedingungen für Methoden als Basis der Methode des Programming (Design) by Contract: „{V} q {N}, p ruft q auf“ bedeutet „Wenn p die Gültigkeit der Vorbedingung V garantiert, dann garantiert auch q die Gültigkeit der Nachbedingung N.“ Klasseninvariante, Schleifeninvariante

45 Sprachkonstrukt für Ausnahmebehandlung
Mehrfachvererbung Generische Klassen als Implementierung parametrisierter ADTs Abstrakte Klassen in Form zurückgestellter Klassen Gezielte Verdeckung von Merkmalen

46 Klassenstruktur: [<Indexierung>] <Klassenkopf> [<formale generische Parameter>] [<veraltete Klasse>] [<Vererbung>] [<Erzeugung>] [<Merkmale>] [<Invariante>] end [--class <Klassenname>]

47 Beispiel: generische Klasse für Hashtabellen hash-fähiger Elemente
indexing names: h_table; access: key,direct; representation: array; size: fixed, resizable class HASH_TABLE[T, V  HASHABLE] inherit TABLE[T, V] redefine load end creation make feature remove(k: V) is --Remove entry of key k require valid_key: is_valid(k) do … ensure not has(k) end; --remove

48 make(n: INTEGER): BOOLEAN is
--Allocate space for n items … end; --make load … ok: BOOLEAN is --Was last operation successful? do Result := control = 0 end; --ok control: INTEGER; Max_control: INTEGER is 5; invariant 0<= control; control <= Max_control end –class HASH_TABLE

49 Anpassung ererbter Merkmale:
Überschreibung: Überschreibbar: Signatur, Implementation, Spezifikation (Vor- und Nachbedingung) Bedingung: Eine überschriebene Signatur muss entsprechend Konformitätsregeln konform zur alten Signatur sein; „Beachtung“ der Bedingungen. Gründe für ein Überschreiben: Unvollständigkeit oder Inkorrektheit für die neue Klasse oder ungenügende Effizienz Ankündigung durch redefine <Merkmalsliste>

50 Umbenennung: - rename <alter Merkmalsname> as <neuer Merkmalsname> - Ziele: Vermeidung von Namenskonflikten, die Ermöglichung des Zugriffs zu gleichnamigen aber unterschiedlichen Merkmalen und die Einführung sprechender Bezeichnungen

51 Implementation von in den Elternklassen zurückgestellten Merkmalen:
Kennzeichnung in Elternklassen mit deferred als abstrakt und Spezifikation mit abstrakten Eigenschaften; Implementierung unter Beachtung der Typkonformitätsregel und der Bedingungen Löschen der Implementation eines geerbten Merkmals: undefine <Liste von Merkmalsnamen> Die angeführten Merkmale werden als zurückgestellt (in der Elternklasse) betrachtet.

52 Beispiel: Umbenennung class C inherit A rename f as g end; B feature … h(x,y:T) is do g(x,y) Verwendung von f aus A f(y) Verwendung von f aus B end end –class C

53 Beispiel: abstrakte Klasse deferred class COMPARABLE feature infix ´´<´´(other: like current): BOOLEAN is deferred end … end –class COMPARABLE

54 class STRING inherit COMPARABLE redefine ´´<´´ end feature
infix´´<´´(other: like current): BOOLEAN is … end –class STRING

55 Vererbungshierarchie:
GENERAL PLATFORM ANY ... NONE

56 B Eltern Vererbungsrelationen: C Kind (Erbe)
A A, B, C sind Vorgänger (Vorfahren) von C A, B, C sind Nachfolger (Nachfahren) von B A A, B sind echte Vorgänger von C C B, C sind echte Nachfolger von A

57 Beispiel: inherit C rename ...
export {D,E,F} Die Merkmale f, g und h der Klasse C werden f,g,h an die Klassen D, E und F „weitergegeben“. {M,N} Die Merkmale k, l und m der Klasse C werden k,l,m an die Klassen M und N „weitergegeben“. redefine end

58 Situationen mit Beachtung der Konformität:
x := y : Der Typ von y muss konform zum Typ von x sein. Typen aktueller Parameter müssen konform zu den Typen der entsprechenden formalen Parameter sein. Das Überschreiben eines ererbten Attributs muss so geschehen, dass der neue Typ konform zum alten Typ ist (Kovarianz). Beim Überschreiben einer Funktion muss der neue Ergebnistyp konform zum alten Ergebnistyp sein. Beim Überschreiben einer Routine müssen die neuen Argumenttypen konform zu den entsprechenden alten Argumenttypen sein.

59 Beispiele: Mehrfachvererbung (wiederholte Vererbung)
Einfache wiederholte Vererbung class B inherit A; A feature ... end –class B Festlegung: A wird nur einfach geerbt.

60 Ererbte Routine wird modifiziert und unter altem Namen bereitgestellt, während die alte Version einen neuen Namen bekommt class B inherit A feature rename make is make as A_make do end; A_make A … redefine end make … select end –class B make end

61 A A make make ererbt und B ererbt und umbenannt überschrieben A_make make

62 Auswahl eines Merkmals bei Ringstruktur
f B C ererbt und f überschrieben f ererbt und D ererbt und umbenannt umbenannt bf cf

63 Auswahl durch select-Klausel in D:
a: A; b: B; c: C; d: D; ... b := d; c := d; a := d; -- erlaubt wegen Konformität b.f; Aufruf von bf c.f; Aufruf von cf a.f; Aufruf von bf oder cf? Auswahl durch select-Klausel in D: class D inherit B rename f as bf select bf end;

64 Varianten der Objekterzeugung:
Voraussetzung: Klasse C definiert Objekttyp T, x sei vom Typ T C enthalte keine Erzeugungsprozedur: !!x bedeutet a) Erzeugung eines neuen Objekts als Instanz vom Typ T b) Initialisierung aller Objektkomponenten durch Standardwerte c) Setzen der Referenz von x auf das Objekt

65 C enthalte eine Erzeugungsroutine cp:
!!x.cp(...) bedeutet a) Erzeugung eines neuen Objekts als Instanz vom Typ T b) Initialisierung aller Objektkomponenten durch Standardwerte c) Aufruf von cp(...) angewendet auf das Objekt d) Setzen der Referenz von x auf das Objekt Erzeugung eines Objekts vom Typ V konform mit T: !V!x oder !V!x.cp(...)

66 Beachte folgende Situationen:
Klassendefinition enthält keine creation-Klausel: !!<Variable> mit Standardinitialisierung wird genutzt. Klassendefinition enthält leere creation-Klausel (besteht nur aus creation): Es können keine Objekte als Instanzen dieser Klasse erzeugt werden. Auf Klienten zugeschnittene creation-Klausel (wie feature- Klausel). Eine Erzeugungsroutine verliert beim Vererben ihren Erzeugungscharakter, wenn sie nicht explizit in der creation-Klausel der abgeleiteten Klasse steht.

67 Beispiel: komplexe Zahlen class COMPLEX creation makeComplex
class COMPLEX creation makeComplex feature {NONE} re, im: REAL; -- nicht exportiert feature makeComplex(x, y:REAL) is do re := x; im := y; end; --makeComplex realPart: REAL is do Result := re end; imaginaryPart: REAL is do Result := im end; add(y: COMPLEX) is re := re + y.realPart; im := im + y.imaginaryPart; end; --add

68 subtract(y: COMPLEX) is do re := re - y.realPart; im := im - y.imaginaryPart; end; --subtract negate is re := -re; im := -im; end; --negate multiply(y: COMPLEX) is local r, i: REAL; r := re * y.realPart – im * y.imaginaryPart; i := im * y.realPart + re * y.imaginaryPart; re := r; im := i; end; --multiply divide(y: COMPLEX) is ... end; --class COMPLEX

69 x, y, z: COMPLEX; … !!x.makeComplex(1.0, 1.0) ; --erzeuge ein Objekt mit der komplexen Zahl i 1.0 und setze eine Referenz von x zu --ihm !!y.makeComplex(2.0, -1.0); --erzeuge ein Objekt mit der komplexen Zahl --2.0 – i1.0 und setze eine Referenz von y zu ihm z := clone(x); --z zeigt auf eine Kopie des von x gezeigten --Objekts z.add(y); --z zeigt auf die Summe der von x und y --gezeigten komplexen Zahlen

70 Zusicherungen in Eiffel:
Klasseninvariante: Eigenschaften aller Objekte der Klasse zu stabilen Situationen Schleifeninvariante: - Zweck der Schleife in Form von Beziehungen zwischen Programmvariablen - gilt vom Eintritt bis zum Verlassen der Schleife (bei Verlassen gilt zusätzlich Abbruchbedingung) - variant-Klausel kontrolliert über Integer- Ausdruck Erreichung des Schleifenendes (Verminderung in jedem Durchlauf, aber nie negativ)

71 - Schleifenstruktur: from ... Initialisierung invariant
... Schleifeninvariante variant ... Variant-Klausel until ... Bedingung für Schleifenende loop ... Schleifenkörper end

72 Vor- und Nachbedingungen für Routinen
check-Klausel: an allen Anweisungsstellen erlaubt zur Formulierung von lokalen Eigenschaften Vor- und Nachbedingungen für Routinen Prozedurdefinition: <Prozedurname>(<Argumente>) is require Vorbedingung local Deklaration lokaler Elemente do Prozedurkörper ensure Nachbedingung end

73 Ausnahmesituationen:
Falscher Alarm: Meldung einer Ausnahme ohne Einfluss auf weitere Abarbeitung  normale Fortsetzung Wiederaufnahme: Softwarekomponente mit vorbedachten Alternativen für den Ausnahmefall  Fortsetzung nach ausgewählter Alternative Organisierte Panik: keine Möglichkeit der Vertragserfüllung  Objekte werden in akzeptablen Zustand versetzt und es erfolgt eine Misserfolgsmeldung an Kunden

74 try_once_or_twice is --Solve problem using method 1 or, if unsuccessful, method 2 local already_tried: BOOLEAN; do if not already_tried then method_1 else method_2 end rescue if not already_tried then already_tried := true; retry end end –try_once_or_twice

75 try_and_record is --Attempt to solve problem using method 1 or, if unsuccessful, method 2. --Set impossible to true if neither method succeeded, false otherwise. local already_tried: BOOLEAN; do if not already_tried then method_1 elseif not impossible then method_2 end rescue if already_tried then impossible := true end; already_tried := true; retry end –try_and_record

76 Java Ziele und Charakteristika:
Softwareaustausch zwischen unterschiedlicher Hardware Als selbständige OOPS entwickelt, aber mit imperativen Sprachkonstrukten Elementare Datentypen wie in imperativen Sprachen, aber in Klassen einpackbar (wrapper) Gewisse Möglichkeiten der Metaprogrammierung

77 Parallelarbeit durch Ausführungsstränge (threads)
Objektlokale und klassenlokale Variablen und Methoden Schnittstellenkonzept Applet-Nutzung Netzprogrammierung

78 Klasse, Objekt Klasse: neuer Objekttyp + Implementierung
Aufbau einer Klasse: [<Modifikatorenliste>] class <Klassenname> {<Liste von Attribut-, Konstruktor- und Methodendeklarationen>} Methodendeklaration: [<Modifikatorenliste>] <Ergebnistyp> <Methodenname> ([<Parameterliste>]) [<throws-Deklaration>] <Methodenrumpf>

79 Konstruktor: Dient der Erzeugung von Objekten und der Initialisierung der objektlokalen Variablen Konstruktorname = Klassenname Bereitstellung durch Nutzer oder Standard Aufruf: new <Klassenname> (<aktuelle Parameter>) Programm: Kollektion von Klassen Eine Klasse enthält Klassenmethode main: public static void main (String[ ] argf) {...}

80 Imperative Konstrukte Werte, Variablen, Ausdrücke
Elemente eines Datentyps Objektreferenzen Referenz null Operationen: Auf Objekten oder deren Referenzen Auf Basisdatentypen Auf allen Datentypen (z.B. ==, !=, =)

81 Zuweisung <Variable> = <Ausdruck>:
Berechnung des Ausdruckwertes und Zuweisung zur Variablen auf der linken Seite Wert der Zuweisung = Wert des Ausdrucks Operandentypen: bei ungleichen Typen Implizite Konvertierung: ganzahlige Typen in größere Bereiche oder Gleitkomma Explizite Konvertierung: (<gewünschter Typ>) <Ausdruck> (Gewünschter Typ und Ausdruckstyp müssen miteinander vereinbar sein.)

82 Imperative Konstrukte Anweisungen, Blöcke
Ausdruck (Zuweisung, Methodenaufruf, arithmetischer Ausdruck, logischer Ausdruck) Bedingte Anweisungen: - if (<logischer Ausdruck>) <Anweisung> - if (<logischer Ausdruck>) <Anweisung1> else <Anweisung2> Mehrfache Alternative (switch-Anweisung)

83 Schleifen: - while (<logischer Ausdruck>) <Anweisung> - do <Anweisung> while (<logischer Ausdruck>) - for (<Init-Ausdruck>; <logischer Ausdruck>; <Ausdruck>) <Anweisung> Block: Variablendeklarationen und Anweisungen gemischt und eingeschlossen in { } Zählt als zusammengesetzte Anweisung

84 Beispiele: result = 1; for (i = 2; i <=n; i = i + 1) result = result * i; i = 2; while (i <= n) {result = result * i; i = i + 1;} switch (n) { case 0:...; break; case 1:...; break; ... case 10:...; break; default:...; }

85 Spezielle Anweisungen:
break: Verlassen der umfassenden Anweisung (Beispiel siehe oben) return [<Ausdruck>]: Verlassen eines Methodenrumpfes mit eventuellem Ergebnis

86 Ausnahmebehandlung Aufbau der try-Anweisung: try <Block> enthält Anweisungen, die eine Ausnahme verursachen könnten catch (<Ausnahmetyp> <Bezeichner>) <Block> ... [finally <Block>]

87 Beispiel: int m; String str = ´´007L´´; try {
m = Integer.parseInt(str); } catch (NumberFormatException e) { System.out.println(´´str keine int-Konstante´´); m = 0} System.out.println(m);

88 Allgemeine Abarbeitung der try-Anweisung:
Fehlerfreie Ausführung des try-Blocks: - Ausführung des finally-Blocks - Normale Terminierung der try-Anweisung und Fortsetzung mit nachfolgender Anweisung Abrupte Beendigung des try-Blocks durch Ausnahme Ex: - Passender catch-Block existiert: 1. Ausführung des catch-Blocks 2. Ausführung des finally-Blocks 3. Normale Terminierung der try-Anweisung und Fortsetzung mit nachfolgender Anweisung

89 - Sonst (kein passender catch-Block): 1
- Sonst (kein passender catch-Block): 1. Ausführung des finally-Blocks 2. Wird die try-Anweisung von weiterer try- Anweisung umfasst, erfolgt Weitergabe von Ex an sie; ansonsten erfolgt abrupte Terminierung mit Ausnahme Ex. Direkte Auslösung einer Ausnahme mit throw- Ausdruck.

90 try-Block Ausnahme Keine Ausnahme catch-Block finally-Block

91 Propagierung von Ausnahmen:
Innerhalb von Hierarchien von Throw- Blöcken zum unmittelbar umfassenden throw-Block Von aufgerufener Methode zum Aufrufer durch throws-Deklaration im Methodenkopf [<Modifikatorenliste>] <Ergebnistyp> <Methodenname> ([<Parameterliste>]) [<throws-Deklaration>] <Methodenrumpf>

92 Strukturen mit Klassen, Sichtbarkeit
Paket als Zusammenfassung logisch zusammengehöriger Klassen Vererbungsstruktur für Klassifikation Verschachtelung von Klassen (innere Klassen) zur Erleichterung der Handhabung

93 Anwendungaspekte für Pakete:
Gute Strukturierung Einteilung in Namensräume und Festlegung von Zugriffsrechten Separate Übersetzung Wiederverwendung von Klassen Steuerung des Zugriffs zu Konstrukten eines Pakets: Kein Modifikator (default access): paketlokaler Zugriff public: uneingeschränkte Nutzung private: klassenlokaler Zugriff protected: Zugriff durch abgeleitete Klassen

94 Person Druckbar Student Angestellte wissMitarbeiter nwMitarbeiter HSL

95 interface Druckbar {void drucken();} class Student extends Person
class Person {...} interface Druckbar {void drucken();} class Student extends Person implements Druckbar {...} class Angestellte extends Person class wissMitarbeiter extends Angestellte class nwMitarbeiter extends Angestellte class HSL extends Angestellte

96 Typen Basisdatentypen Referenz- oder Objekttypen Klassentypen Schnittstellentypen Feldtypen

97 Beispiel: Dynamisches Binden für Untertypen des Schnittstellentyps Druckbar class NumDruck{ private static int Nummer = 1; private static void DruckMitNum(Druckbar d){ System.out.println(´´Posten´´+Nummer+´´:´´); d.drucken(); Nummer ++; }

98 Vererbung: Geerbt werden alle Attribute, Methoden und inneren Klassen der Oberklassen, falls ein Zugriff erlaubt ist Spezialfall Konstruktoren: Im Unterklassenkonstruktor kann direkt auf den Oberklassenkonstruktor durch super(<Parameter>) oder implizit als erste Anweisung des Unterklassenkonstruktors auf den parameterlosen Oberklassenkonstruktor zugegriffen werden. Anpassung einer geerbten Methode: Ersetzen durch Methode gleicher Signatur oder Zugriff auf Methode der Oberklasse durch super.<Methodenname>(<Parameter>) mit Ergänzung Zusätzliche Attribute, Methoden und innere Klassen

99 private Entry header = new Entry(null, null, null);
class LinkedList{ private Entry header = new Entry(null, null, null); private int size = 0; LinkedList(){ header.next = header; header.previous = header; } ListElem getLast(){…} ListElem removeLast(){…} void addLast(ListElem e){…} int size(){…}

100 private ListElem element; private Entry next; private Entry previous;
private static class Entry{ private ListElem element; private Entry next; private Entry previous; Entry(ListElem element, Entry next, Entry previous){…} }

101 element element element next next next previous previous previous
LinkedList Entry header element null size next previous Entry Entry Entry element element element next next next previous previous previous ListElem ListElem ListElem

102 class MyClassIsMyCastle {
private static int streetno = 169; private static class FirstFloor { private static class DiningRoom { private static int size = 36; private static void mymessage() { System.out.print(´´I can access streetno´´); System.out.println(´´:´´+streetno); } private static class SecondFloor { private static class Bathroom { private static int size = 16; private static void mymess() { System.out.print(´´I can access the ´´); System.out.print(´´dining room size: ´´); System.out.println(´´ ´´+FirstFloor.DiningRoom.size);

103 public static void main(String[] argv){
FirstFloor.DiningRoom.mymessage(); SecondFloor.Bathroom.mymess(); }

104 streetno 169 MyClassIsMyCastle FirstFloor
streetno MyClassIsMyCastle FirstFloor DiningRoom FirstFloor SecondFloor size 36 mymessage DiningRoom BathRoom SecondFloor BathRoom size 16 mymess main

105 class LinkedList { private Entry header = new Entry(null, null, null); private int size = 0; … private static class Entry { }

106 class ListIterator { private int nextIndex = 0; private Entry next = header.next; boolean hasNext(){ return nextIndex != size; } ListElem next(){ if (nextIndex == size) throw new NoSuchElementException(); ListElem elem = next.element; next = next.next; nextIndex ++; return elem; ListIterator listIterator(){ Return new ListIterator();

107 LinkedList header element null next null previous null size 0 Entry ListIterator nextIndex 0 next element next previous hasNext listIterator

108 Beispiel: Anwendung des Schnittstellenkonzepts auf die Implementierung des Beobachtermusters (nach A. Poetzsch-Heffter: Konzepte objektorientierter Programmierung) Schnittstelle: interface Beobachter { void steigen(Aktie a); void fallen(Aktie a); }

109 Aktienklasse: import java. util
Aktienklasse: import java.util.*; public class Aktie { private String name; private int kurswert; private ArrayList beobachterliste; Aktie(String n, int anfangswert){ name = n; kurswert = anfangswert; beobachterliste = new ArrayList(); }

110 public void anmeldenBeobachter(Beobachter b) { beobachterliste
public void anmeldenBeobachter(Beobachter b) { beobachterliste.add(b); } public String getName() { return name; public int getKurswert() { return kurswert;

111 void setKurswert(int neuerWert) { int alterWert = kursWert; kursWert = neuerWert>0 ? neuerWert : 1; ListIterator it = beobachterliste.listIterator(); if(kursWert > alterWert) { while(it.hasNext() ) { Beobachter b = (Beobachter)it.next(); b.steigen(this);} } else { Beobachter b = (Beobachter) it.next(); b.fallen(this);} }

112 Aktieninteressent: class Kunde1 implements Beobachter { private boolean besitzt = false; public void fallen(Aktie a) { if(a.getKurswert() < 300 && !besitzt) { System.out.println(´´Kauf von ´´+a.getName() ); besitzt = true; }} public void steigen(Aktie a) { if(a.getKurswert() > 400 && besitzt) { System.out.println(´´Verkauf von ´´+a.getName() ); besitzt = false;

113 Schlafend E/A beendet E/A-blockiert
interrupt Zeit abgelaufen E/A sleep   yield Neu Rechenbereit Rechnend start Scheduling Tot wait interrupt notify/ Monitor besetzt notifyAll Monitor Wartend frei Monitor-blockiert Prozesszustände und -übergänge terminiert

114 Erzeugung von Strängen:
Ableitung einer neuen Thread-Klasse K aus der Klasse Thread mit Überschreiben der Methode run: class K extends Thread{ ... public void run(){ } Thread meinThread = new K(); meinThread.start();

115 2. Ableitung einer neuen Klasse K von einer beliebigen Klasse O mit gleichzeitiger Implementierung der Schnittstelle Runnable: class K extends O implements Runnable ... public void run(){ } Runnable meinZiel = new K(); Thread meinThread = new Thread(meinZiel); meinThread.start();

116 PACKAGE Keller_Verwaltung IS
-- Typvereinbarungen TYPE Keller IS PRIVATE; -- Unterprogrammvereinbarungen FUNCTION Leer (K: Keller) RETURN Boolean; -- Leer zeigt an, ob der Keller leer ist. PROCEDURE Push (K: IN OUT Keller; Was: IN Integer); -- Ein Element wird in den Keller gefuellt. PROCEDURE Pop (K: IN OUT Keller); -- Das Element an der Kellerspitze wird entfernt. FUNCTION Read (K: Keller) RETURN Integer; -- Das Element an der Kellerspitze wird gelesen. FUNCTION Groesse (K: Keller) RETURN Natural; -- Gibt die Anzahl der Kellerelemente an.

117 -- Ausnahmesituationen
Kellerueberlauf: EXCEPTION RENAMES Storage_Error Leerer_Keller: EXCEPTION; PRIVATE TYPE Komponente; TYPE Komponenten_Zeiger IS ACCESS Komponente; TYPE Komponente IS RECORD Information: Integer; Weiter: Komponenten_Zeiger; END RECORD; TYPE Keller IS RECORD Anker: Komponenten_Zeiger := 0; Groesse: Natural := 0; END Keller_Verwaltung;

118 Paket X Kindpaket X.Y Deklarationen öffentlich öffentlich privat privat Körper

119 GENERIC Size: Positive; TYPE Item IS PRIVATE; PACKAGE Stack IS PROCEDURE Push (E: IN Item); PROCEDURE Read (E: OUT Item); Overflow, Underflow: EXCEPTION; END Stack;

120 PACKAGE BODY Stack IS TYPE Table IS ARRAY (Positive RANGE <>) OF Item; Space: Table (1..Size); Index: Natural := 0; PROCEDURE Push (E: Item) IS BEGIN IF Index >= Size Then RAISE Overflow END IF; Index := Index + 1; Space (Index) := E; END Push; PROCEDURE Read (E: OUT Item) IS BEGIN IF Index = 0 THEN RAISE Underflow; END IF; E := Space(Index); Index := Index – 1; END Read; END Stack;

121 TYPE F_Nummer IS RANGE 1..10; TYPE Richtung IS (N, O, S, W);
-         TYPE Tastenart IS (Zeichen, Funktion, Pfeil, Unbekannt); TYPE F_Nummer IS RANGE 1..10; TYPE Richtung IS (N, O, S, W); TYPE Taste (Art: Tastenart := Unbekannt) IS RECORD CASE Art IS WHEN Zeichen  Z: Character; WHEN Funktion  F: F_Nummer; WHEN Pfeil  R: Richtung; WHEN Unbekannt  NULL; END CASE; END RECORD;

122 WITH Calendar, People; PACKAGE Alert_System IS TYPE Alert IS TAGGED RECORD Time_Of_Arrival: Calendar.Time; Message: Text; END RECORD; PROCEDURE Display(A: IN Alert); PROCEDURE Handle(A: IN OUT Alert); PROCEDURE Log(A: IN Alert); TYPE Low_Alert IS NEW Alert WITH NULL RECORD;

123 TYPE Medium_Alert IS NEW Alert WITH
RECORD Action_Officer: People.Person; END RECORD; -- neue Handle-Operation PROCEDURE Handle(MA: IN OUT Medium_Alert); TYPE High_Alert IS NEW Medium_Alert WITH Ring_Alarm_At: Calendar.Time; PROCEDURE Handle(HA: IN OUT High_Alert); PROCEDURE Set_Alarm(HA: IN High_Alert); END Alert_System;

124 Low_Alert Medium_Alert
Low_Alert Medium_Alert High_Alert

125 PACKAGE Sets IS SUBTYPE Element_Type IS Natural; TYPE Set IS ABSTRACT TAGGED NULL RECORD; FUNCTION Empty RETURN Set IS ABSTRACT; FUNCTION Union (Left, Right: Set) RETURN Set IS ABSTRACT; FUNCTION Intersection (Left, Right: Set) RETURN Set IS ABSTRACT; FUNCTION Unit_Set (Element: Element_Type) RETURN Set IS PROCEDURE Take (Element: OUT Element_Type; From: IN OUT Set) IS ABSTRACT; END Sets;

126 -- Private Vereinbarung des Typs Geometrisches_Objekt im Paket Geo
PACKAGE Geo IS TYPE Geometrisches_Objekt IS ABSTRACT TAGGED PRIVATE;   TYPE Pixel_Koordinaten IS RECORD X, Y: Integer; END RECORD ; TYPE Bildschirmfarbe IS RANGE 0..15 ; PROCEDURE Verlagere (Was: IN OUT Geometrisches_Objekt; Wohin: IN Pixel_Koordinaten);   PROCEDURE Zeige (Was: IN Geometrisches_Objekt) IS Abstract; PRIVATE TYPE Geometrisches_Objekt IS TAGGED Farbe: Bildschirmfarbe; Bezugspunkt: Pixel_Koordinaten; END RECORD; END Geo;

127 -- Private Vereinbarung des Typs Flaechenobjekt im Paket
-- Geo.Flaechenobjekte PACKAGE Geo.Flaechenobjekte IS TYPE Flaechenobjekt IS ABSTRACT NEW Geometrisches_Objekt WITH PRIVATE; PRIVATE Geometrisches_Objekt WITH RECORD Gefuellt: Boolean; END RECORD; END Geo_Flaechenobjekte;

128 -- Private Vereinbarung des Typs Kreis im Paket
-- Geo.Flaechenobjekte.Kreise PACKAGE Geo.Flaechenobjekte.Kreise IS TYPE Kreis IS ABSTRACT NEW Flaechenobjekt WITH PRIVATE; PRIVATE WITH RECORD Radius: Float; END RECORD; END Geo.Flaechenobjekte.Kreise;

129 -- Private Vereinbarung des Typs Rechteck im Paket
-- Geo.Flaechenobjekte.Rechtecke PACKAGE Geo.Flaechenobjekte.Rechtecke IS TYPE Rechteck IS ABSTRACT NEW Flaechenobjekt WITH PRIVATE; PRIVATE Flaechenobjekt WITH RECORD Eckpunkt_2: Pixel_Koordinaten; END RECORD; END Geo.Flaechenobjekte.Rechtecke;

130 Paketstruktur Geo Flaechenobjekte Kreise Rechtecke

131 Typstruktur Geometrisches_Objekt Farbe Bezugspunkt
Flaechenobjekt Farbe Gefuellt Kreis Farbe Rechteck Farbe Bezugspunkt Bezugspunkt Gefuellt Gefuellt Radius Eckpunkt_2

132 Anwendung des Pakets Geo
-- Ausgabe einer Reihung geometrischer Objekte WITH Geo; PACKAGE Geo_Reihungen IS TYPE Geo_Zeiger IS ACCESS Geo.Geometrisches_Objekt´Class; TYPE Geo_Reihung IS ARRAY (Positive RANGE <>) OF Geo_Zeiger; PROCEDURE Zeige (Was: IN Geo_Reihung); END Geo_Reihungen;

133 WITH Geo; USE Geo; PACKAGE BODY Geo_Reihungen IS PROCEDURE Zeige (Was: IN Geo_Reihung) IS BEGIN FOR I IN Was´Range LOOP Zeige (Was (I).ALL); END LOOP; END Zeige; END Geo_Reihungen;

134 a parent x y b parent c parent y y z z

135 Merkmalsobjekt Allgemeines Merkmalsobjekt
parent clone + print - a parent b parent c parent y y y z z z

136 c n x x 15 y 4 c.clone  n y 4 m1 m1 x 15 n ADDS x 15 n REMOVE y m1 VAR z z 10 10  z m1 METHOD m2 … ; m2 ENDADDS

137 Prototyp N Klasse N N-Objekt n
Prototyp P P-Objekt P1 Klasse P Eltern P-Objekt P2 Kind Kind Prototyp N Klasse N N-Objekt n