Bernhard Lahres, Gregor Raýman
Praxisbuch Objektorientierung Von den Grundlagen zur Umsetzung
Auf einen Blick 1
Einleitung ..............................................................................
11
2
Die Basis der Objektorientierung .........................................
25
3
Die Prinzipien des objektorientierten Entwurfs ...................
37
4
Die Struktur objektorientierter Software .............................
63
5
Vererbung und Polymorphie ................................................. 153
6
Persistenz ............................................................................. 299
7
Abläufe in einem objektorientierten System ........................ 337
8
Module und Architektur ....................................................... 503
9
Aspekte und Objektorientierung .......................................... 527
A
Anhang .................................................................................. 575
B
Literaturverzeichnis .............................................................. 593 Index ..................................................................................... 597
Inhalt 1
Einleitung ................................................................................. 11 1.1 1.2 1.3
1.4
2
11 12 13 14 16 18 19 21 21 23 23
Die Basis der Objektorientierung ............................................ 25 2.1 2.2 2.3 2.4
3
Was ist Objektorientierung? ........................................................ Hallo liebe Zielgruppe .................................................................. Was bietet dieses Buch (und was nicht)? ...................................... 1.3.1 Bausteine unseres Buchs ............................................... 1.3.2 Crosscutting Concerns: übergreifende Anliegen ............. 1.3.3 Und was ist mit Übungsaufgaben? ................................. 1.3.4 Die Rolle von Programmiersprachen ............................. Warum überhaupt Objektorientierung? ....................................... 1.4.1 Gute Software: Was ist das eigentlich? .......................... 1.4.2 Die Rolle von Prinzipien ................................................ 1.4.3 Viele mögliche Lösungen für ein Problem ......................
Die strukturierte Programmierung als Vorläufer der Objektorientierung ...................................................................... Die Kapselung von Daten ............................................................ Polymorphie ................................................................................ Die Vererbung ............................................................................. 2.4.1 Vererbung der Spezifikation .......................................... 2.4.2 Erben von Umsetzungen (Implementierungen) ..............
26 29 30 32 32 33
Die Prinzipien des objektorientierten Entwurfs ...................... 37 3.1 3.2 3.3 3.4 3.5 3.6 3.7
Prinzip 1: Prinzip einer einzigen Verantwortung ........................... Prinzip 2: Trennung der Anliegen ................................................ Prinzip 3: Wiederholungen vermeiden ........................................ Prinzip 4: Offen für Erweiterung, geschlossen für Änderung ........ Prinzip 5: Trennung der Schnittstelle von der Implementierung ... Prinzip 6: Umkehr der Abhängigkeiten ......................................... 3.6.1 Umkehrung des Kontrollflusses ..................................... Prinzip 7: Mach es testbar ...........................................................
38 43 45 48 51 54 58 60
5
Inhalt
4
Die Struktur objektorientierter Software ................................ 63 4.1
4.2
4.3
4.4
5
63 64 72 77 79 81 82 82 86 90 100 103 110 114 115 117 118 119 122 123 125 126 129 130 130 131 134 137 144
Vererbung und Polymorphie .................................................... 153 5.1
6
Die Basis von allem: das Objekt ................................................... 4.1.1 Eigenschaften von Objekten: Objekte als Datenkapseln 4.1.2 Operationen und Methoden von Objekten ................... 4.1.3 Kontrakte: Ein Objekt trägt Verantwortung ................... 4.1.4 Die Identität von Objekten ........................................... 4.1.5 Objekte haben Beziehungen ......................................... Klassen: Objekte haben Gemeinsamkeiten ................................... 4.2.1 Klassen sind Modellierungsmittel .................................. 4.2.2 Kontrakte: die Spezifikation einer Klasse ....................... 4.2.3 Klassen sind Datentypen ............................................... 4.2.4 Klassen sind Module ..................................................... 4.2.5 Sichtbarkeit von Daten und Methoden .......................... 4.2.6 Klassenbezogene Methoden und Attribute .................... 4.2.7 Singleton-Methoden: Methoden für einzelne Objekte ... Beziehungen zwischen Objekten .................................................. 4.3.1 Rollen und Richtung einer Assoziation .......................... 4.3.2 Navigierbarkeit ............................................................. 4.3.3 Kardinalität ................................................................... 4.3.4 Qualifikatoren ............................................................... 4.3.5 Beziehungsklassen, Attribute einer Beziehung ............... 4.3.6 Implementierung von Beziehungen ............................... 4.3.7 Komposition und Aggregation ....................................... 4.3.8 Attribute ....................................................................... 4.3.9 Beziehungen zwischen Objekten in der Übersicht ......... Klassen von Werten und Klassen von Objekten ........................... 4.4.1 Werte in den objektorientierten Programmiersprachen ................................................... 4.4.2 Entwurfsmuster Fliegengewicht ..................................... 4.4.3 Aufzählungen (Enumerations) ....................................... 4.4.4 Identität von Objekten ..................................................
Die Vererbung der Spezifikation .................................................. 5.1.1 Hierarchien von Klassen und Unterklassen .................... 5.1.2 Unterklassen erben die Spezifikation von Oberklassen ... 5.1.3 Das Prinzip der Ersetzbarkeit ........................................ 5.1.4 Abstrakte Klassen, konkrete Klassen und Schnittstellen-Klassen ...................................................
153 153 155 159 165
Inhalt
5.2
5.3
5.4
5.5
6
5.1.5 Vererbung der Spezifikation und das Typsystem ............ 5.1.6 Sichtbarkeit im Rahmen der Vererbung ......................... Polymorphie und ihre Anwendungen ........................................... 5.2.1 Dynamische Polymorphie am Beispiel ........................... 5.2.2 Methoden als Implementierung von Operationen ......... 5.2.3 Anonyme Klassen .......................................................... 5.2.4 Single und Multiple Dispatch ........................................ 5.2.5 Die Tabelle für virtuelle Methoden ................................ Die Vererbung der Implementierung ............................................ 5.3.1 Überschreiben von Methoden ....................................... 5.3.2 Das Problem der instabilen Basisklassen ........................ 5.3.3 Problem der Gleichheitsprüfung bei geerbter Implementierung .......................................................... Mehrfachvererbung ..................................................................... 5.4.1 Mehrfachvererbung: Möglichkeiten und Probleme ........ 5.4.2 Delegation statt Mehrfachvererbung ............................. 5.4.3 Mixin-Module statt Mehrfachvererbung ........................ 5.4.4 Die Problemstellungen der Mehrfachvererbung ............. Statische und dynamische Klassifizierung ..................................... 5.5.1 Dynamische Änderung der Klassenzugehörigkeit ........... 5.5.2 Entwurfsmuster Strategie statt dynamischer Klassifizierung ...............................................................
174 181 191 193 198 207 208 227 238 240 248 253 260 260 267 270 272 288 289 293
Persistenz ................................................................................. 299 6.1 6.2
6.3
6.4
Serialisierung von Objekten ......................................................... Speicherung in Datenbanken ....................................................... 6.2.1 Relationale Datenbanken .............................................. 6.2.2 Struktur der relationalen Datenbanken .......................... 6.2.3 Begriffsdefinitionen ....................................................... Abbildung auf relationale Datenbanken ....................................... 6.3.1 Abbildung von Objekten in relationalen Datenbanken ................................................................ 6.3.2 Abbildung von Beziehungen in relationalen Datenbanken ................................................................ 6.3.3 Abbildung von Vererbungsbeziehungen auf eine relationale Datenbank ................................................... Normalisierung und Denormalisierung ......................................... 6.4.1 Die erste Normalform: Es werden einzelne Fakten gespeichert ...................................................................
299 300 300 301 302 307 307 311 315 320 321
7
Inhalt
6.4.2 6.4.3 6.4.4 6.4.5
7
323 325 329 331
Abläufe in einem objektorientierten System ........................... 337 7.1
7.2
7.3
7.4
7.5
8
Die zweite Normalform: Alles hängt vom ganzen Schlüssel ab .................................................................. Die dritte Normalform: Keine Abhängigkeiten unter den Nichtschlüssel-Spalten .................................. Die vierte Normalform: Trennen unabhängiger Relationen .................................................................... Die fünfte Normalform: Einfacher geht’s nicht ...............
Erzeugung von Objekten mit Konstruktoren und Prototypen ....... 7.1.1 Konstruktoren: Klassen als Vorlagen für ihre Exemplare ..................................................................... 7.1.2 Prototypen als Vorlagen für Objekte ............................. 7.1.3 Entwurfsmuster Prototyp .............................................. Fabriken als Abstraktionsebene für die Objekterzeugung ............. 7.2.1 Statische Fabriken ......................................................... 7.2.2 Abstrakte Fabriken ........................................................ 7.2.3 Konfigurierbare Fabriken ............................................... 7.2.4 Registraturen für Objekte .............................................. 7.2.5 Fabrikmethoden ............................................................ 7.2.6 Erzeugung von Objekten als Singletons ......................... 7.2.7 Dependency Injection ................................................... Objekte löschen ........................................................................... 7.3.1 Speicherbereiche für Objekte ........................................ 7.3.2 Was ist eine Garbage Collection? .................................. 7.3.3 Umsetzung einer Garbage Collection ............................. Objekte in Aktion und in Interaktion ........................................... 7.4.1 UML: Diagramme zur Beschreibung von Abläufen ......... 7.4.2 Nachrichten an Objekte ................................................ 7.4.3 Iteratoren und Generatoren .......................................... 7.4.4 Funktionsobjekte und ihr Einsatz als Eventhandler ........ 7.4.5 Kopien von Objekten .................................................... 7.4.6 Sortierung von Objekten ............................................... Kontrakte: Objekte als Vertragspartner ........................................ 7.5.1 Überprüfung von Kontrakten ........................................ 7.5.2 Übernahme von Verantwortung: Unterklassen in der Pflicht ................................................................. 7.5.3 Prüfungen von Kontrakten bei Entwicklung und Betrieb ...................................................................
338 338 342 348 349 352 355 360 364 368 377 386 397 397 399 400 412 412 421 421 433 442 452 455 455 457 470
Inhalt
7.6
8
471 472 478 484 488 493 501
Module und Architektur .......................................................... 503 8.1
8.2
9
Exceptions: Wenn der Kontrakt nicht eingehalten werden kann ............................................................. 7.6.1 Exceptions in der Übersicht ........................................... 7.6.2 Exceptions und der Kontrollfluss eines Programms ........ 7.6.3 Exceptions im Einsatz bei Kontraktverletzungen ............ 7.6.4 Exceptions als Teil eines Kontraktes .............................. 7.6.5 Der Umgang mit Checked Exceptions ............................ 7.6.6 Exceptions in der Zusammenfassung .............................
Module als konfigurierbare und änderbare Komponenten ............ 8.1.1 Relevanz der Objektorientierung für Softwarearchitektur ....................................................... 8.1.2 Erweiterung von Modulen ............................................. Die Präsentationsschicht: Model, View, Controller (MVC) ............ 8.2.1 Das Beobachter-Muster als Basis von MVC ................... 8.2.2 MVC in Smalltalk: Wie es ursprünglich mal war ............. 8.2.3 MVC: Klärung der Begriffe ............................................ 8.2.4 MVC in Webapplikationen: genannt »Model 2« ............ 8.2.5 MVC mit Fokus auf Testbarkeit: Model-View-Presenter ..................................................
503 503 505 511 512 513 514 518 523
Aspekte und Objektorientierung ............................................. 527 9.1
9.2
9.3
Trennung der Anliegen ................................................................ 9.1.1 Kapselung von Daten .................................................... 9.1.2 Lösungsansätze zur Trennung von Anliegen ................... Aspektorientiertes Programmieren ............................................... 9.2.1 Integration von aspektorientierten Verfahren in Frameworks .................................................................. 9.2.2 Bestandteile der Aspekte .............................................. 9.2.3 Dynamisches Crosscutting ............................................. 9.2.4 Statisches Crosscutting .................................................. Anwendungen der Aspektorientierung ......................................... 9.3.1 Zusätzliche Überprüfungen während der Übersetzung ... 9.3.2 Logging ......................................................................... 9.3.3 Transaktionen und Profiling .......................................... 9.3.4 Design by Contract ....................................................... 9.3.5 Introductions ................................................................ 9.3.6 Aspektorientierter Observer ..........................................
527 531 532 539 539 540 541 548 551 551 552 553 556 559 560
9
Inhalt
9.4
Annotations ................................................................................. 9.4.1 Zusatzinformation zur Struktur eines Programms ........... 9.4.2 Annotations im Einsatz in Java und C# .......................... 9.4.3 Beispiele für den Einsatz von Annotations .....................
563 563 565 566
Anhang ........................................................................................... 575 A
B
Anhang .................................................................................................. A.1 Verwendete Programmiersprachen .............................................. A.1.1 C++ ............................................................................... A.1.2 Java .............................................................................. A.1.3 C# ................................................................................. A.1.4 JavaScript ...................................................................... A.1.5 CLOS ............................................................................ A.1.6 Python .......................................................................... A.1.7 Ruby ............................................................................. Literaturverzeichnis ................................................................................ B.1 Allgemeine Bücher zur Softwareentwicklung ................................ B.2 Bücher über die UML und die verwendeten Programmiersprachen ..................................................................
575 575 575 578 581 582 584 587 590 593 593 595
Index ............................................................................................................ 597
10
In diesem Kapitel werfen wir vorab bereits einen Blick auf die technischen Möglichkeiten, die uns die Objektorientierung bietet. Und wir stellen die Basiskonzepte Datenkapselung, Vererbung und Polymorphie kurz vor, ohne bereits ins Detail zu gehen.
2
Die Basis der Objektorientierung
Vor der Frage, wie objektorientierte Verfahren am besten eingesetzt werden, drängt sich die Frage auf, warum Sie denn solche Verfahren einsetzen sollten. Die Objektorientierung hat sich seit Anfang der Neunzigerjahre des letzten Jahrhunderts als Standardmethode der Softwareentwicklung etabliert. Aber nur weil etwas mittlerweile als Standard gilt, muss es noch lange nicht nützlich sein. Das alleine reicht als Motivation für objektorientierte Verfahren nicht aus. Die Techniken der objektorientierten Softwareentwicklung unterstützen uns dabei, Software einfacher erweiterbar, besser testbar und besser wartbar zu machen.
Objektorientierung löst einige Probleme, ...
Allerdings dürfen Sie sich von der Objektorientierung nicht Antworten auf alle Probleme und Aufgabenstellungen der Softwareentwicklung erwarten. Die Erwartungen an die Möglichkeiten dieser Vorgehensweise werden in vielen Projekten zu hoch gesteckt.
... aber nicht alle.
Zum einen führt die Nutzung objektorientierter Basismechanismen und objektorientierter Programmiersprachen nicht automatisch zu guten Programmen. Zum anderen adressiert die Objektorientierung einige Problemstellungen gar nicht oder bietet nur unvollständige Lösungsstrategien dafür. Bei der Vorstellung des Prinzips der Trennung von Anliegen im nächsten Kapitel werden Sie zum Beispiel sehen, dass die Objektorientierung dieses Prinzip nur unvollständig unterstützt. Die Objektorientierung bietet aber einen soliden Werkzeugkasten an, der es uns erlaubt, die Zielsetzungen der Entwicklung von Software anzugehen. Die Basiswerkzeuge in diesem Werkzeugkasten sind die drei Grundelemente objektorientierter Software:
25
Grundelemente der Objektorientierung
2
Die Basis der Objektorientierung
왘
Datenkapselung
왘
Polymorphie
왘
Vererbung
Wir geben im Folgenden einen kurzen Überblick über die drei Basistechniken. Dabei werden wir auf Begriffe vorgreifen müssen, die erst später im Buch eingeführt werden. Sie sollen aber hier bereits einen ersten Eindruck davon erhalten, welche Möglichkeiten die Objektorientierung bietet. Die Details und formalen Definitionen werden wir Ihnen im weiteren Verlauf des Buchs nachreichen, versprochen. Um Ihnen die Vorteile der objektorientierten Programmierung verdeutlichen zu können, beginnen wir aber zunächst mit einer Kurzzusammenfassung der Verfahren der strukturierten Programmierung, die ja der Vorläufer der objektorientierten Vorgehensweise ist.
2.1
Die strukturierte Programmierung als Vorläufer der Objektorientierung
Die objektorientierte Softwareentwicklung baut auf den Verfahren der strukturierten Programmierung auf. Um die Motivation für die Verwendung von objektorientierten Methoden zu verstehen, gehen wir einen Schritt zurück und werfen einen Blick auf die Mechanismen der strukturierten Programmierung und auch auf deren Grenzen. Programmiersprachen, die dem Paradigma1 des strukturierten Programmierens folgen, sind zum Beispiel PASCAL oder C. Die Struktur von Programmen und Daten
Der Inhalt des benutzten Computerspeichers kann für die meisten Programme in zwei Kategorien unterteilt werden. Einerseits enthält der Speicher Daten, die bearbeitet werden, andererseits enthält er Instruktionen, die bestimmen, was das Programm macht.2 1 Als Paradigma wird in der Erkenntnistheorie ein System von wissenschaftlichen Leitlinien bezeichnet, das die Art von Fragen und die Methoden zu deren Beantwortung eingrenzt und leitet. Im Bereich der Programmierung bezieht sich der Begriff auf eine bestimmte Sichtweise, welche die Abbildung zwischen Wirklichkeit und Programm bestimmt. 2 Die Daten eines Programms können Instruktionen eines anderen Programms sein. Zum Beispiel stellt der Java-Bytecode Instruktionen für ein Java-Programm dar, für die Java Virtual Machine (JVM) ist der Java-Bytecode jedoch eine Sammlung von Daten. Ein anderes Beispiel sind Compiler, deren Ausgabedaten Instruktionen für die kompilierten Programme sind.
26
Die strukturierte Programmierung als Vorläufer der Objektorientierung
2.1
Jetzt werden Sie auf einige Begriffe treffen, die Ihnen sehr wahrscheinlich bekannt sind, die aber unterschiedlich interpretiert werden können. Wir schicken deshalb einige kurze Definitionen vorweg. Routine
Definition:
Ein abgegrenzter, separat aufrufbarer Bestandteil eines Programms. Eine Routine kann entweder Parameter haben oder ein Ergebnis zurückgeben. Eine Routine wird auch als Unterprogramm bezeichnet. Routinen sind das Basiskonstrukt der strukturierten Programmierung. Indem ein Programm in Unterprogramme zerlegt wird, erhält es seine grundsätzliche Struktur.
Funktion Eine Funktion ist eine Routine, die einen speziellen Wert zurückliefert, ihren Rückgabewert.
Prozedur Eine Prozedur ist eine Routine, die keinen Rückgabewert hat. Eine Übergabe von Ergebnissen an einen Aufrufer kann trotzdem über die Werte der Parameter erfolgen.
Die Unterscheidung zwischen Funktion und Prozedur, die wir hier getroffen haben, bewegt sich auf der Ebene von Programmen. Mathematische Funktionen ließen sich sowohl über Prozeduren als auch Funktionen abbilden. Ein Weg, der stets wachsenden Komplexität der erstellten Programme Herr zu werden, ist die Strukturierung der Instruktionen und der Daten. Statt einfach die Instruktionen als einen monolithischen Block mit Sprüngen zu implementieren, werden die Instruktionen in Strukturen wie Verzweigungen, Zyklen und Routinen unterteilt. In Abbildung 2.1 ist ein Ablaufdiagramm dargestellt, das die Berechnung von Primzahlen als einen solchen strukturierten Ablauf darstellt.
Strukturierung von Instruktionen und Daten
Außerdem werden Daten bei der strukturierten Programmierung nicht als ein homogener Speicherbereich betrachtet, man benutzt globale und lokale, statisch und dynamisch allozierte Variablen, deren Inhalte definierte Strukturen wie einfache Typen, Zeiger, Records, Arrays, Listen, Bäume oder Mengen haben. In den strukturierten Programmiersprachen definieren wir Typen der Daten, und wir weisen sie den Variablen, die sie enthalten können, zu. Auch die Parameter der Routinen, also der Prozeduren und der Funktionen, haben definierte Typen, und wir können sie nur mit entsprechend strukturierten Daten aufrufen. Eine Prozedur mit falsch strukturierten
27
Typen von Daten
2
Die Basis der Objektorientierung
Parametern aufzurufen, ist ein Fehler, der im besten Falle von einem Compiler erkannt wird, im schlimmeren Falle zu einem Laufzeitfehler oder einem Fehlverhalten des Programms führt. Ausgabe 2, 3
n := 5
i := 3
n := n + 2
n mod i = 0 wahr falsch
i := i + 2
i*i>n falsch
Abbildung 2.1 Kontrolle und Verantwortung beim Programmierer
Ausgabe n wahr
Ablaufdiagramm zur Berechnung von Primzahlen
Der Programmierer hat die volle Kontrolle darüber, welche Routinen mit welchen Daten aufgerufen werden. Die Macht des Programmierers ist jedoch mit der Verantwortung verbunden, dafür zu sorgen, dass die richtigen Routinen mit den richtigen Daten aufgerufen werden. In Abbildung 2.2 ist eine andere Variante der Darstellung für den Ablauf bei der Berechnung von Primzahlen dargestellt. Die in den so genannten Nassi-Shneiderman-Diagrammen gewählte Darstellung bildet besser als ein Ablaufdiagramm die zur Verfügung stehenden Kontrollstrukturen ab. Wir sehen: Das strukturierte Programmieren war ein großer Schritt in die Richtung der Beherrschung der Komplexität. Doch wie jede Vorgehensweise stößt auch diese bei bestimmten Problemen an ihre Grenzen. Eine Erweiterung der gewählten Vorgehensweise wird dadurch notwendig. Die Objektorientierung stellt die Erweiterungen bereit. Im Folgenden lernen Sie die drei wichtigsten Erweiterungen in einem kurzen Überblick kennen.
28
Die Kapselung von Daten
2.2
Ausgabe 2, 3 n := 5 i := 3 solange (i * i < n) und (n mod i != 0)
i := i + 2 i*i>n wahr
falsch
Ausgabe n
n := n + 2 wiederholen
Abbildung 2.2
2.2
Nassi-Shneiderman-Diagramm: bessere Darstellung der Struktur
Die Kapselung von Daten
In der strukturierten Programmierung sind Daten und Routinen voneinander getrennt. Die Objektorientierung verändert diese Sicht durch die Einführung von Objekten. Daten gehören nun explizit einem Objekt, ein direkter Zugriff wie auf die Datenstrukturen in der strukturierten Programmierung ist nicht mehr erlaubt. Objekte haben damit also das alleinige Recht, ihre Daten zu verändern oder auch lesend auf sie zuzugreifen. Möchte ein Aufrufer (zum Beispiel ein anderes Objekt) diese Daten lesen oder verändern, muss er sich über eine klar definierte Schnittstelle an das Objekt wenden und eine Änderung der Daten anfordern. Der große Vorteil besteht nun darin, dass das Objekt selbst dafür sorgen kann, dass die Konsistenz der Daten gewahrt bleibt. Falls zum Beispiel zwei Dateneinträge immer nur gemeinsam geändert werden dürfen, kann das Objekt dies sicherstellen, indem eine Änderung eines einzelnen Wertes gar nicht vorgesehen wird. Ein weiterer Vorteil besteht darin, dass von einer Änderung der zugrunde liegenden Datenstruktur nur die Objekte betroffen sind, die diese Daten verwalten. Wenn jeder beliebig auf die Daten zugreifen
29
Konsistenz der Daten
Index A Abarbeitungsreihenfolge, für Sammlung von Objekten festlegen 452 abgeleitete Klassen, arbeiten nicht mehr? 228 Abhängigkeit implizit 46, 47 sichtbar machen 43 zwischen Modulen und Klassen aufheben 387 Ablauf 337 Beschreibung 412 Ablaufsteuerung 506 Abstract Windowing Toolkit 566 Abstrakte Fabrik 355 Definition 357 abstrakte Fabrik, Verwendung 357 abstrakte Klassen 165, 168 in C++ 171 in Java und C# 172 Umsetzung 171 Abstrakte Methoden 168 Abstraktion 54 Definition 54 Accept Event Action 415 action-mappings 521 Advice, Definition 543 Aggregate 126 Aggregation 117, 126 Definition 126 UML 127 Aktion, Sichtweisen 412 Aktivitätsbereich 414 Aktivitätsdiagramm 412, 413 Alternativschlüssel 305 Analysemodell 84 Änderungen, an Basisklassen und Schnittstellen 228 Anforderung, Änderung 40 Anliegen 43 durch ein Modul repräsentieren 43 in einem Modul 530 in unterschiedlichen Modulen 45
Trennung 44 übergreifend 530 Anmerkung 씮 Annotation Annotation 563 @Override 565 @SuppressWarnings 566 Definition 565 vordefiniert 565 Anonyme Klassen 207 Java 438 Anwendungscontainer 539 Anwendungsfalldiagramm 412 Anwendungsrahmen 506 AspectJ 21, 547 Aspekt, Definition 543 Aspekte 527 Aspektorientierte Frameworks 540 Aspektorientierter Observer 560 Aspektorientiertes Programmieren 539 Aspektorientierung, Anwendung 551 Assoziation 115 Formen 116 in UML 117 Richtung 117 Rollen 117 Assoziationsklasse 124 Assoziationsklassen, UML 124 asynchrone Nachricht 419 Attribute 66, 129 Aufzählung Elemente mit Methoden 138 typsicher und serialisierbar 143 Aufzählungen 137 als abgegrenzte Mengen von Objekten 137 Ausnahme 씮 Exception Automatische Speicherbereinigung 씮 Garbage Collection AWT 566
B Basisklassen instabil 248 Kopplung mit abgeleiteter Klasse 248
597
Index
Benutzerfreundlichkeit 22 Beobachter-Muster mit Aspektorientierung umsetzen 560 MVC 512 Beziehung als Assoziation, Komposition, Aggregation? 129 Attribute 123 beidseitig navigierbar 125 Einschränkungen in UML 121 einwertig 125 Implementierung 125 in relationaler Datenbank abbilden 311 Kardinalität 119 Klassen und Objekte 115 mehrwertig 120, 121, 125 Navigierbarkeit 118 Richtung 117 Umsetzung 125 zwischen Objekt und Teilen 117 Beziehung 씮 Assoziation Beziehungsklasse 124 UML 123 Beziehungsklassen 123 Boyce-Codd-Normalform 329
C C# 581 Methoden überschreiben 248 partielle Klasse 377 Sichtbarkeitsstufen 110 Typisierung 98 C++ 575 Compiler 578 Klassen als Module 102 Methoden überschreiben 247 späte Bindung 227 Struktur 575 Syntax 576 Typisierung 98, 99 C++-Konstruktoren, Polymorphie 237 Chain of Responsibility 367 Checked Exception 491 als Unchecked Exception weiterreichen 498 Definition 491 Umgang 493 Class Table Inheritance 319
598
Clone-Operation 446 Java 447 CLOS 584 Struktur 585 Syntax 585 Code Scattering, Definition 530 Code Smell 488 Code Tangling, Definition 530 Code-Durcheinander 씮 Code Tangling Code-Redundanz vermeiden durch Vererbung 243 vermeiden mittels Fabrik 355 Code-Streuung 씮 Code Scattering Collection 186 Collection 씮 Sammlung Common Lisp Object System 584 Composite Pattern 씮 Entwurfsmuster Kompsition Concrete Table Inheritance 318 Constructor Call 545 Constructor Execution 545 Constructor Injection 395 Container 539 Definition 509 Komplexitäten abbauen 392 Controller in MVC, Definition 514 Copy-Konstruktor 341 Java 444 Crosscutting dynamisch 541 statisch 541 Crosscutting Concern 541 Definition 530 implementieren 541 in Klassen einarbeiten 541
D Daten 26 Typen 27 Daten eines Objekts, Definition 65 Datenbankidentität 147 Datenelemente, Zugriff 546 Datenkapselung 29, 64, 66 Bedeutung 69 Nachteile 71 Datenmodell in dritte Normalform bringen 326 in zweite Normalform überführen 324
Index
Datensatz 303 Datenstruktur, definieren 47 Datentypen 90 Delegaten-Klassen 440 Definition 439 Delegation als Alternative zu Vererbung 248, 267 Definition 268 Delphi, Typisierung 99 Demeter-Prinzip Nutzen 206 Verletzung 206 Denormalisierung 321 Dependency Injection 386, 510 Definition 387 Einsatz 396 Übergabe 394 Varianten 394 Dependency Inversion Principle 씮 Prinzip der Umkehr der Abhängigkeiten Design by Contract 556 Design Patterns 씮 Entwurfsmuster Designmodell 84 Diamantenregel 281 Diensteverzeichnis, Definition 396 Dispatcher 197 Don’t repeat yourself 45 Double-checked Locking 381 Downcast 178 Dritte Normalform 325 Ducktyping 93 Dynamisch typisierte Programmiersprachen rein spezifizierende Klassen 167 Dynamische Klassifizierung 288 Dynamische Pointcuts 554 Dynamische Typisierung 93 Dynamischer Speicher 397 Dynamisches Crosscutting Definition 541 Dynamisches Typsystem 92
E Eigenschaft eines Objekts 64 Einfache Klassifizierung 84 Eingabe-Controller 515 Einweben 541
Einwertige Beziehung 125 Enterprise Java Beans 149 Entity Beans 149, 151 Entity-Relationship-Darstellung 312 Entwurfsmuster 17 Abstrakte Fabrik 349 Beobachter 262 Beobachtetes-Beobachter 512 Besucher 222 Fliegengewicht 131, 134 Kompositum 226 Prototyp 348 Schablonenmethode 244 Strategie 293, 506 Zuständigkeitskette 367 Enumerations 137 Ereignis 421 Ersatzkomponente 61 Ersetzbarkeit 276 Unterklassen 457 Erweiterung, Module 505 Erweiterungsmodul 50 Erweiterungspunkt 50, 505 bestimmen 507 hinzufügen 51 Eventhandler 421, 433 Definition 435 Exception 471, 472 Ausführungspfade 480 Einsatz 475 Kontrakte formulieren 489 Kontrollfluss eines Programms 478 Teil eines Kontrakts 488 vs. Fehlercode 477 werfen 472 Exception Handling Definition 480 Exception Safety 479 Definition 480 Exception-Sicherheit 씮 Exception Safety Exemplar 82 Definition 84 Exemplare einer Klasse erzeugen 111 verwalten 111 Exposed Joinpoints 544
599
Index
F Fabrik 349 abstrakt 355 Definition 349 für Module unsichtbar machen 387 Konfigurierbar 360 Schnittstelle 357 über Datei konfigurieren 361 Fabrikmethode 368 Anwendung 372 Bedingung 372 Definition 349 Eigenschaften 371 Unterschied abstrakte Fabrik 371 Factory Pattern 350 Fehlercode 477 Fehlersituation, Bekannt 489 field access 546 Finale Klassen 248 Flache Kopie 449 Fliegengewicht Entwurfsmuster 135 Flyweight 씮 Fliegengewicht Fragile Base Class Problem 249 Fragile Binary Interface Problem 227 Framework 51, 506 Fremdschlüssel 306 Function Objects 씮 Funktionsobjekte Fünfte Normalform 331 Funktion 302 Definition 27 Funktionale Abhängigkeit 304 Funktionalität Abweichungen festhalten 50 umsetzen 46 zwangsweise nutzen 243 Funktionsobjekte 421, 433 Definition 436
G Garbage Collection 399 Arten 400 Definition 399 Lebensdauer von Objekten 409 Umsetzung 400 Varianten 399 Geerbte Methode, überschreiben 565
600
Generalisierung 154 Generat 534 Generator 421 C# 431 Java 430 Problem 430 Zweck 422 Generator als Methode 430 Generics 96 generierter Code 534 Geschachtelte Klassen 189 in C# und C++ 190 Java 189 geschützt innerhalb des Packages 109 geschützte Datenelemente, Zugriff 182 Gleichheit 253 Eigenschaften 254 prüfen 253 prüfen in Java 255 Gleichheitsprüfung bei Vererbungsbeziehung 254 Formale Kriterien 254 globale Variable und Singleton 385
H Heap 398 Hibernate 537 Hierarchie von Klassen virtuelle-Methoden-Tabelle 229
I Identität 79, 130, 144, 148 Identität von Objekten, Definition 79 Implementierung 51 Beziehungen 125 vererben 238 Implementierungen, Aufrufen 242 Implementierungsmodell, Definition 85 Implizite Abhängigkeit 46, 47 Indirektion 50 inner classes 189 instabile Basisklassen 248 Instance 씮 Exemplar Interaktionsübersichtsdiagramm 413 Interface Injection 395 Nachteil 395
Index
interface 씮 Schnittstellen-Klassen Interzeptor Definition 542 Implementierung 542 Introduction 549, 559 Warnungen 550 Introspektion 538 Invariante 88 Inversion of Control 58 Iterator 424 Definition 185, 425 dynamisch 425
J Jakarta Struts 519 Java 578 finale statische Variable 143 Generator 430 geschachtelte Klassen 189 Identität von Objekten 149 Klassen als Module 100 Methoden überschreiben 247 Protokolle 351 Sichtbarkeitsstufen 109 Struktur 579 Syntax 579 Typisierung 97 virtuelle Machine (Garbage Collection) 409 JavaScript 75, 582 Erweiterung von Objekten 345 Funktionen 343 Hierarchie von Prototypen 345 Klassen 342 Objekt erzeugen 342 Struktur 582 Syntax 583 Typisierung 98 Vererbung 345 Vererbungskette 347 JDBC 369 Joinpoint Arten 544 Aufruf einer Operation 545 Ausführung einer Methode 545 Ausführung eines Konstruktors 545 Definition 542
offen gelegt 544 Zugriff auf die Datenelemente 546 JUnit 508
K Kapselung von Daten 29, 66 Kardinalität 119 UML 120 Klassen 82, 90, 174 Abstrakt 165 abstrakt 168 als Vorlagen 338 Anonym 207 Beziehungen untereinander 115 Definition 82 Elemente 100 erweitern mit Aspektorientierung 559 Erzeugung von Exemplaren 545 Exemplare erzeugen 111 final 248 Geschachtelt 189 Konformität 158 konkret 165 Kontrakt 86 Kopplung mit Typ 92 Methoden und Daten zuordnen 110 Modul 100 Parametrisiert 94 Schnittstelle 87 Schnittstelle trennen 53 Spezifikation 85 Spezifikation durch Kontrakt 86 spezifizierend 166 Klassen als Module, Java 100 Klassen und Typen, koppeln 92 Klassen von Objekten 130 Klassen von Werten 130 klassenbasierte Elemente, Verwendung 111 Klassenbasierte Sichtbarkeit 105 Klassenbezogene Attribute 110 Klassenbezogene Konstanten 113 Klassenbezogene Methoden 110 klassenbezogene Methoden, Hilfsfunktionen 112 Klassenhierarchie auf relationale Datenbank abzubilden 315
601
Index
Klassenhierarchien anpassen bei Typsystemen 174 Klassenmanipulation durch Aspekte 541 Klassenzugehörigkeit dynamisch ändern 289 Klassifizierung 288 Definition 83, 84 dynamisch 289 einfach 84 mehrfach 84 Kohäsion maximieren 42 Kommunikationsmodul 43 Komparator 452 Komplexität 21 beherrschen durch Strukturierung 27 reduzieren 43, 46 Komplexität beherrschen, Prinzipien 37 Komposition 117, 126 bei Hierarchie 128 Definition 126 Einsatz 128 UML 127 Konfigurationsdateien 564 Konfigurierbare Fabrik 360 Definition 361 in Sprachen ohne Reflexion 363 Umsetzung 361 Umsetzung in Java 361 Konformität 158 Konkrete Klassen, Definition 165 Konstante benannte 46 klassenbezogen 113 Konstruktor 338 Aufruf 545 Ausführung 545 Gruppen 339 mit Initialisierung 340 Konstruktoraufruf 111 Konstruktoren 111 Kontrakt 455 Klassen 86, 155 Operation 77 prüfen 464 Prüfung durch Methode 468 überprüfen 455 Überprüfung mit Aspektorientierung 557 von Objekten 77
602
Kontraktverletzung durch Programmierfehler 489 Exception 484 Kontrollfluss eines Programms unterbrochen 472 verlassen 472 Kontrollfluss, Umkehrung 387 Kopie 442 als Prototyp 443 Eigenschaften 447 flach 449 Sammlung 443 Tiefe 448 und Zyklische Referenz 449 Kopieren aller referenzierten Objekte 406 Kopiervorgang, Endlosschleife 449 Kopplung minimieren 42 Korrektheit 22 Kovariante Typen 276
L Laufzeitpolymorphie 192 Laufzeitumgebungen 509 Law of Demeter 204 Law of leaky Abstractions 227 Lazy Initialization 380, 382 leichtgewichtiger Container 392, 510 lightweight container 392 Link (UML) 117 Logging Lösung mit Aspektorientierung 552
M Manipulation von Klassen 541 Mark and Sweep 400 Mark and Sweep 씮 Markieren und Löschen von referenzierten Objekten Markieren und Löschen Problem 406 Markieren von referenzierten Objekten 400 mehrfache Klassifizierung 84 Mehrfachvererbung 260 Datenstrukturen in C++ 282 Datenstrukturen in Python 282 Ersetzung durch Komposition 286
Index
Operationen und Methoden in Python 279 Problemstellung 272 von Operationen und Methoden C++ 278 Mehrfachvererbung der Implementierung 262 ersetzen in Java und C# 267 Problem 265 Mehrfachvererbung der Spezifikation 260 Java und C# 274 Mehrfachverwendbarkeit, Modul 41 Mehrfachverwendung 135 Vorteil 136 Mehrwertige Beziehungen 120 Message Driven Beans 149 Metainformation 536, 563 Definition 536 Metaobjekt, Definition 536 method_missing 204 Methode abstrakt 168 als Implementierung von Operationen 198 anhand von Typ der Objekte bestimmen 209 Aufruf 204 Ausführung 545 Definition 73 für Überschreiben sperren 247 Implementierung 73 paarweise aufrufen 244 Scheitern anzeigen 477 überschreiben 240 überschrieben 245 Ursache für Nichterfüllung der Aufgabe 475 Methodenaufruf, verkettet 205 Methodenimplementierung, Interface 549 Mixin C++ 272 Definition 270 mit Klassen verwenden 559 Ruby 270 Mock-Objekte 61 Model 1 für Webapplikationen 519 Model 2 für Webapplikationen 519 Modell in MVC, Definition 515 Modellierung, der Schnittstelle 180
Modellierungsplacebo 128 Model-View-Controller 씮 MVC Model-View-Presenter 523 Modul 38, 503 Abhängigkeiten 38, 41, 42, 57 Änderung 57 Änderung vermeiden 48 Anforderungen umsetzen 39 Anpassungsfähigkeit 48 Erweiterbarkeit 49 Erweiterung 505 Formulierung der Abhängigkeiten 51 Identifikation 40 Kopplung 42 Mehrfachverwendbarkeit 41 Schnittstelle 51 Testbarkeit 60 Verantwortung 38, 39 Verwendungsvarianten 50 zusammenführen 46 Zweck 39 Multiple Dispatch Definition 210 Entwurfsmuster Besucher 214, 215 Java 210 mit Unterstützung, durch die Programmiersprache 214 ohne Unterstützung durch die Programmiersprache 210 Praxisbeispiel 214, 215 Multiplizität 씮 Kardinalität MVC 511, 512 Ansatz 511 Begriffsdefinitionen 514 in Webapplikationen 518 Testbarkeit 523 Ursprung 513
N Nachbedingung 88 Nachricht an Objekte 421 Namenskonvention 564 Nassi-Shneiderman-Diagramm 29 natürlicher Schlüssel 309 Navigierbarkeit 118 UML 118
603
Index
Nebenläufigkeit Java 380 Neustart bei Kontraktverletzung 485 NULL-Werte 306
O Oberklassen 154 ändern 174 Vererbung 158 ObjectPascal, Typisierung 99 Objekt 29, 63 Aktion und Interaktion 412 Assoziation 115 Attribute 129 Beziehungen 115 Darstellung in UML 67 Datenkapselung 64 Definition 63 Eigenschaften 66 erzeugen 338 Funktionalität 72 gleichartig 82 Gleichheit 253 identisch 145 Identität 79, 130, 144 in relationaler Datenbank abbilden 307 Klassenzugehörigkeit bestimmen 360 Konstruktion 235 Kontrakt 455 kopieren 341, 442 Laufzeit überdauern 299 Lebenszyklus 509 Methode 73 Nachrichtenaustausch 419 Operation 455 prüft Kontrakt 464 Rolle 81 Sammlung 421 Serialisierung 299 sortieren 452 Spezifikation von mehreren Klassen erfüllen 260 und Daten 74 und Operation 72 und Routine 423 Verhalten modifizieren 344 Zustand merken 442
604
Objekt erzeugen JavaScript 342 Konstruktor 338 Prototyp 342 Singleton 377 Verfahren 338 Objekt und Exemplar Unterschied 83 Objekt und Routine Unterschied 423 Objektbasierte Sichtbarkeit 106 Objekte und Werte Unterscheidung 79 Objekteigenschaften 64 Objekterstellung 338 Objektfluss 415 Objektidentität 148 Objektinitialisierungs-Joinpoint 546 Objektknoten 415 Objektkopie erstellen 444 flach 341 tief 341 Zweck 442 objektorientierte Analyse 17 objektorientierte Architektur 503 objektorientierte Programmiersprachen Grundelemente 12 objektorientierte Software Struktur 63 objektorientiertes System Komplexität reduzieren 43 Vorteil 421 Zustände verwalten 415 objektorientiertes Systemdesign 504 Objektorientierung Basis 25 Definition 11 Grundelemente 25 Prinzipien 23, 37 Zweck 21 Objekt-relationale Abbildungsregeln Dritte Normalform 327 Vierte Normalform 331 Zweite Normalform 325 Objekt-Relationale Mapper 301 Observable-Observer 씮 Entwurfsmuster, Beobachtetes-Beobachter
Index
Offen für Erweiterung, Geschlossen für Änderung Entwurfsmuster Besucher 225 Offen für Erweiterung, geschlossen für Änderung 48 Online-Quiz 18 Open-Closed-Principle 48 Operation 72 auf Objekten ohne Klassenbeziehung aufrufen 200 auf primitiven Datentypen 112 Aufruf 72, 545 Definition 72 Deklaration 74, 168 implementieren 198 Kontrakt 77 mehreren Objekten zuordnen 210 Semantik 455 Syntax 455 Operationen mit gleicher Signatur C# 277 Java 275
P parametrisierte Klassen 94 C++ 190 in UML 94 Java 96 Parametrisierte statische Fabrik 355 Partielle Klasse 376 Persistenz 299 Plugin 511 Pointcut Arten 547 Definition 543 polymorphe Methoden 228 Konstruktion und Destruktion von Objekten 235 Polymorphie 30 Definition 192 statisch 193, 229 Vorteile 32, 196 Polymorphie im Konstruktor Java 236 Postconditions 88 Präsentationsschicht 511 Preconditions 87 primitive Datentypen 112
Prinzip der Datenkapselung Vorteile 30 Prinzip der Ersetzbarkeit 160, 176, 276 Gründe für Verletzung 164 Vererbung der Spezifikation 159 Prinzip der Umkehr der Abhängigkeiten 54 Prinzip einer einzigen Verantwortung 38, 71 Entwurfsmuster Besucher 225 Regeln 42 Vorteil 40 Prinzip Trennung der Schnittstelle von der Implementierung 51 Prinzip Trennung von Anliegen 43 Prinzip Wiederholungen vermeiden Umsetzung 46 Prinzipien 37 Private Methoden Ruby 106 private Vererbung 183 in Delegationsbeziehung umwandeln 183 Profiling 553 program to interfaces 51 Programmabbruch 485 Programm direkt beenden 487 Programm in definierter Weise beenden 486 Programmierfehler Ursachen 489 Programmiersprachen strukturierte 26 Programmverhalten ändern mit Annotations 566 Protected 181 protected internal 110 Protokollierung der Abläufe 552 Prototyp 342 Definition 342 Entwurfsmuster 348 Prozedur, Definition 27 Prozess 423 Prüfung des Kontrakts an Aufrufstelle 469 bei Entwicklung 470 beim Aufruf von Operationen 468 gegenüber Implementierung 468 mit Aspektorientierung 470
605
Index
Python 93, 587 Syntax 588 Typisierung 98
Q Qualifikatoren 122 UML 123 Quelle 534 Quelltext 534 ändern 48 in verschiedene Quelltextmodule verteilen 377 kopieren 47 mit generierten Anteilen 535 Redundanz 533 Wiederholungen 45 Quelltextgenerierung 533 Probleme 534
R RAII 씮 Resource Acquisition is Initialisation Redundanz 45 bewusst 321 vermeiden 243 Reference Counting 400 Referenz 145 Referenzielle Integrität 312 Referenzzähler 400 Reflection 씮 Reflexion Reflexion 363 Definition 538 Registratur 360, 364, 371 Relation 303 relationale Datenbanken 300 Begriffsdefinition 303 Partitionierung 309 Struktur 301 Resource Acquisition is Initialisation 482 Responsibility 38 Richtung einer Assoziation 117 Rollen UML 117 Routinen 423 als Objekte 436 Definition 27
606
Ruby 374, 590 private Methoden 106 Sichtbarkeitsstufe Geschützt 108 Syntax 590 Typisierung 98
S Sammlung 424 Kopie 443 über generischen Mechanismus kopieren 447 Sammlung von Objekten, stellt Iterator bereit 185 Sammlungsbibliothek 185 San Francisco Framework Classes 509 Schablonenmethode 244, 507 Schlüssel 304 Schlüsselkandidaten 305 Schnittstelle Definition 73 Implementierung 51 implizit und explizit 274 minimal vs. benutzerorientiert 549 von Implementierung trennen 73 von Klasse trennen 53 Schnittstelle einer Klasse, Definition 87 Schnittstellen-Klassen 53, 166 Definition 166 in C++ 171 in Java und C# 172 Umsetzung 171 schwach typisierte Programmiersprachen 97 Separate Fabrik 373 Separation of Concerns 43 Sequenzdiagramm 413, 419 Serialisierung von Objekten 299 Service Locator 396 Session Beans 149 set 121 Sichtbarkeit auf aktuelles Objekt einschränken 105 Vererbung 181 Sichtbarkeitskonzept klassenbasierte 105 objektbasiert 106 Sichtbarkeitskonzept, klassenbasiert 182
Index
Sichtbarkeitsstufe Geschützt 181 Öffentlich 104 Privat 104 Zweck 104 Sichtbarkeitsstufe XE 110 Signal Send Action 415 Single Dispatch Definition 209 Single Responsibility Principle 38 Single Table Inheritance 317 Singleton Einsatz 385 oder globale Variable 385 statische Initialisierung 382 Umsetzung in Java 378 Singleton-Klasse 377 Singleton-Methoden 114 Definition 114 Smalltalk Typisierung 98 Smart Pointer 401 soft references 400 Software Anforderungen 21, 22 Design verbessern 62 Testbarkeit 60 Umsetzung der Ziele 23 Softwarearchitektur 503 Sortierkriterien 453 Späte Bindung 192 realisieren 228 Speicherbereich 397 Speicherersparnis 136 Sperre mit zweifacher Prüfung 381 Spezifikation einer Klasse 89 Spolsky, Joel 227 Stack 397 Standardkonstruktor 340 Stark typisierte Sprachen Definition 97 Stateful Session Beans 149, 150 Stateless Session Beans 149, 150 statisch typisiert 97 statisch typisierte Programmiersprachen rein spezifizierende Klassen 167 statische Fabrik 352 Definition 353
parametrisiert 355 Umsetzung 354 Statische Klassifizierung 288 Statische Polymorphie 193, 228 Statischer Speicher 397 statisches Crosscutting 548 Definition 541 Statisches Typsystem 91 Strategieklassen 295 Struktur Darstellung 29 von objektorientierter Software 63 von Programmen und Daten 26 Struktur des Programms, bei Laufzeit lesen 537 Strukturierte Programmierung 26 Mechanismen 26 Subclass 씮 Unterklasse Swing 566 Synchrone Nachricht 419
T Tabelle für virtuelle Methoden 421 Template Method 245 Test 60 automatisiert 60 Vorteile 61 Testprogramm 60 throws-Klausel erweitern 494 tiefe Kopie 449 Timingdiagramm 413 Top-down-Entwurf 54 To-Space 406 Transaktion 553 über dynamische Pointcuts 554 Trennung der Anliegen 43, 527 Trennung der Schnittstelle von der Implementierung 51 Trennung, Daten und Code 69 try-catch-Block 475 Tupel 303 Typ eines Objekts zum Typ einer Unterklasse konvertieren 178 Typbestimmung zur Laufzeit 179 typisierte Sprachen redundanter Code 94
607
Index
Typisierung schwach 97 stark 97 Vor- und Nachteile 99 Typkonflikte 91 Typsystem 92 dynamisch 92 statisch 91 Vererbung der Spezifikation 174 Typsystem, dynamisch Vorteile 93 Typsystem, statisch Vorteile 91 Typsysteme Definition 90 Typumwandlung in Java 97
U Übergabe an abhängige Module 씮 Dependency Injection übergreifende Anliegen 씮 Crosscutting Concerns überprüfte Exception 씮 Checked Exception Überprüfung während der Übersetzung mit Aspektorientierung 551 Überschreiben von Methoden 240 Überschriebene Methoden 245 Umkehr der Abhängigkeiten 54 Umkehrung des Kontrollflusses Definition 58 UML 412 Aggregation 127 Assoziation 117 Assoziationsklassen 124 Beziehungsklasse 123 Darstellung eines Objekts 67 Diagrammtypen 412 Einschränkungen von Beziehungen 121 Kardinalität 120 Kompostion 127 Navigierbarkeit 118 Qualifikatoren 123 Rollen 117 UML-Diagramme Verwendung 67
608
Unified Modelling Language 16 Unit-Test 60 Unterklassen 154, 155 erben Funktionalität 238 Exemplare 159 Nachbedingungen ändern 162 und Invariante 163 Vorbedingung der Operationen 459 Vorbedingungen verändern 162 Untermodul 38 Unterprogramm aufrufen 28 update anomaly 324
V value object 씮 Wertobjekt Variable 27 Vererbung 32 Erweiterung von Modulen 505 öffentliche Sichtbarkeit 182 privat 183 Sichtbarkeit 181, 182 Varianten 240 Vererbung der Implementierung 33, 238 Problem 248 Programmiersprachen 239 Verbot der Modifikation 243 Vererbung der Spezifikation 33 Definition 155 Typsystem 94, 174 Vererbung von Implementierungen Vorteil 243 Vererbungsbeziehungen in relationaler Datenbank abbilden 315 Vererbungsmöglichkeit fehlend 270 Vergleicher 452 Vergleichsoperation der Basisklasse umsetzen 257 Verhalten von Programmen betrachten 413 Verletzung eines Kontrakts Programmabbruch? 485 Vertrag 씮 Kontrakt Vielgestaltigkeit 191 Vierte Normalform 329 virtual 248
Index
virtuelle Methoden Fehler bei Anpassungen 231 hinzufügen 233 Reihenfolge 230 überschreiben 231 virtuelle Vererbung 286 Virtuelle-Methoden-Tabelle 227 Umsetzung 231 Visitor 216 VMT 씮 Virtuelle-Methoden-Tabelle Vor- und Nachbedingung, Anforderungen 457 Vorbedingung 87 prüfen 468 Überprüfung 556
W Wartbarkeit 22 erhöhen 41 verbessern 46 Weavring 541 Werte 79, 130 als Objekte implementiert 131 Identität 131 objektorientierte Programmiersprachen 131
Wertobjekt 132 Änderung 134 Definition 132 Identität 148 Wiederholung automatisch generiert 48 Entstehung 47 in Quelltexten 45 Wiederholung vermeiden 45
Z Zählen von Referenzen 400 Problem 403 Zusatzinformation in Programmstruktur einbinden 565 Zusicherung 456 Zustand Modellierung 417 Zuständigkeitskette 367 Zustandsautomaten 412 Zustandsdiagramm 412, 415 Zyklische Referenz 403 bei Kopien 449
609
