Page 1


Inhalt

Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XIII Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XV Liebe Leserin, lieber Leser, . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XV Wer dieses Buch aus welchem Grund lesen sollte . . . . . . . . . . . . . . . . . . . . . . . . . .XVII Ihre Meinung ist uns sehr wichtig . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XVIII Danksagungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XVIII Die Autoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XIX

Teil I: Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1

UML 2 – Rückblick, Nabelschau und Ausblick . . . . . . . . . . . . . . . . . . . 3

1.1 1.2 1.3 1.4

Was ist die UML ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .4 ... und was will sie nicht sein?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .4 Entwicklungsgeschichtliches zur UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .5 Diagrammsprachen der UML 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7

2

Vorgehensempfehlungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2.1 2.2

Wissen explizieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Vorgehenstipps aus der UML-Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

3

Grundkonzepte und -elemente der UML . . . . . . . . . . . . . . . . . . . . . . . 13

3.1

Grundkonzepte der UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.1 Repräsentation von UML-Elementen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.2 Diagramm, Diagrammtyp & Sicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Grundelemente der UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.1 Modell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.2 Kommentar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.3 Ausdruck . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.4 Randbedingung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.5 Classifier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.6 Datentyp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.7 Primitiver Typ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.8 Aufzählungstyp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.9 Literal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.10 UML-Schlüsselwörter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3.2

14 14 15 21 21 22 23 24 25 26 28 29 30 31


VI   Inhalt

3.3

3.4

3.5

Strukturierung der Sprache UML 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3.1 Einteilung in Language Units . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3.2 Einteilung in Compliance Levels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Freiheitsgrade in der UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.4.1 Semantic Variation Points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.4.2 Presentation Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die 4-Schichten-Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.5.1 M 0 – Die Laufzeitschicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.5.2 M 1 – Die Modellschicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.5.3 M 2 – Die Metamodellschicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.5.4 M 3 – Die Meta-Metamodellschicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

32 32 32 34 34 34 35 35 35 37 37

4

Analyse mit der UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

4.1

Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1.1 Notwendige Festlegungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1.2 Das Beispiel Zugtürsystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Aufgaben der Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definieren der Systemgrenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Beschreiben der Funktionalitäten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.4.1 Use-Cases identifizieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.4.2 Use-Cases verfeinern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zustandsautomaten in der Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Begriffsmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Verbindung zu natürlich-sprachlichen Anforderungen . . . . . . . . . . . . . . . . . . . . . . . Ausgewählte Modellierungsszenarien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.8.1 Aufgaben von Systemschnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.8.2 Modellierung der Use-Case-Auslöser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.8.3 Modellierung von Interaktionen in Dialogen. . . . . . . . . . . . . . . . . . . . . . . . . 4.8.4 Modellierung einer SOA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.8.5 Weitere Tipps zur Modellierung von Anforderungen . . . . . . . . . . . . . . . . . .

4.2 4.3 4.4

4.5 4.6 4.7 4.8

40 40 42 44 45 47 47 48 54 55 56 58 60 63 65 68 72

5

Die UML in der Realisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

5.1

Systemarchitektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1.1 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1.2 Zerlegen des Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1.3 Verteilen der Verantwortlichkeiten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1.4 Beschreiben der Schnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1.5 Weitere Aspekte der Systemarchitektur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sowareanalyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2.1 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2.2 Beschreibung der Funktionalitäten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2.3 Detaillierte Modellierung des Verhaltens. . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2.4 Weitere Aspekte im Vergleich zur Systemanalyse . . . . . . . . . . . . . . . . . . . . Sowarearchitektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3.1 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3.2 Die Dekompositionssicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.2

5.3

78 78 79 81 82 85 89 89 91 92 92 93 93 93


Inhalt  VII

5.4

5.3.3 Die Kompositionssicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 5.3.4 Weitere Aspekte der Sowarearchitektur . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 Feindesign. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 5.4.1 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 5.4.2 Feindesign für eine objektorientierte Implementierung . . . . . . . . . . . . . . . 99 5.4.3 Feindesign für eine nicht objektorientierte Implementierung . . . . . . . . . 102

Teil II: Strukturdiagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 6

Klassendiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

6.1

Überblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1.1 Modellieren von Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1.2 Grundgedanke der Klassenmodellierung. . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1.3 Klassen und Objekte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1.4 Klassen und Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1.5 Woher kommen Klassen?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anwendungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anwendung im Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.3.1 Konzeptuell-analytische Modellierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.3.2 Logische, designorientierte Modellierung . . . . . . . . . . . . . . . . . . . . . . . . . . Notationselemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.1 Klasse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.2 Attribut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.3 Operation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.4 Schnittstelle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.5 Parametrisierte Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.6 Generalisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.7 Generalisierungsmenge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.8 Assoziation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.9 Assoziationsklasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.10 Abhängigkeitsbeziehung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.11 Verwendungsbeziehung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.12 Abstraktionsbeziehung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.13 Realisierungsbeziehung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.14 Substitutionsbeziehung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.15 Informationsfluss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4.16 Informationseinheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6.2 6.3

6.4

108 108 109 110 110 111 112 113 113 114 115 115 118 123 129 132 135 140 142 157 159 161 162 164 165 166 167

7

Paketdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

7.1 7.2 7.3

Überblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anwendungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anwendung im Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.3.1 Funktionale Gliederung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.3.2 Definition von Schichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Notationselemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

7.4

172 172 173 173 174 175


VIII   Inhalt

7.4.1 7.4.2 7.4.3

Paket. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 Paket-Import / Element-Import . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176 Paket-Merge. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179

8

Objektdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183

8.1

Überblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1.1 Die Inhalte eines Objektdiagramms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1.2 Die Modellierung von Objektdiagrammen. . . . . . . . . . . . . . . . . . . . . . . . . . 8.1.3 Vergleich: Klassen- und Objektdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . Anwendungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anwendung im Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Notationselemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.4.1 Instanzbeschreibung / Objekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.4.2 Werteangaben / Slots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.4.3 Link . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

8.2 8.3 8.4

184 184 185 186 187 187 188 188 190 191

9

Kompositionsstrukturdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

9.1

Überblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1.1 Motivation und Hinführung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1.2 Modellieren von Kollaborationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1.3 Kapselung durch Ports. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anwendungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anwendung im Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.3.1 Darstellung einer Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.3.2 Struktur einer Use-Case-Realisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.3.3 Kennzeichnung und Visualisierung von Design-Pattern . . . . . . . . . . . . . . Notationselemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.4.1 Part. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.4.2 Konnektor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.4.3 Port. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.4.4 Kollaboration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.4.5 Kollaborationsanwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9.2 9.3

9.4

194 196 201 202 203 203 203 204 205 208 208 209 211 212 214

10

Komponentendiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215

10.1 10.2 10.3 10.4

Überblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anwendungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anwendung im Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Notationselemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.4.1 Komponente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.4.2 Artefakt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11

Verteilungsdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227

11.1 Überblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Anwendungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3 Anwendung im Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3.1 Abgrenzung des Systemkontexts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

216 217 218 220 220 223

228 229 229 230


Inhalt  IX

11.3.2 Dokumentation von Hardwarevorgaben. . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.4 Notationselemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.4.1 Knoten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.4.2 Kommunikationspfad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.4.3 Verteilungsbeziehung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.4.4 Einsatzspezifikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

231 231 231 233 234 236

Teil III: Verhaltensmodellierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 12

Use-Case-Diagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241

12.1 Überblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.1.1 Die Use-Case-Analyse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.1.2 Ursprung von Use-Cases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.2 Anwendungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.3 Anwendung im Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.3.1 Typische Anwendungsbereiche. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.3.2 Use-Cases und danach? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.4 Notationselemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.4.1 Use-Case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.4.2 System (Betrachtungsgegenstand) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.4.3 Akteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.4.4 «include»-Beziehung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.4.5 «extend»-Beziehung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

242 242 243 244 245 245 245 246 246 249 251 256 258

13 Aktivitätsdiagramm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263 13.1 Überblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.1.1 Modellieren von Aktivitäten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.1.2 Das Token-Konzept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.1.3 Ursprung der Aktivitätsmodellierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.2 Anwendungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3 Anwendung im Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3.1 Geschäsprozessmodellierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3.2 Beschreibung von Use-Cases. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3.3 Implementierung einer Operation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4 Notationselemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.1 Aktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.2 Aktivität. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.3 Objektknoten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.4 Kanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.5 Kontrollelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.6 Startknoten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.7 Endknoten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.8 Verzweigungs- und Verbindungsknoten . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.9 Synchronisations- und Parallelisierungsknoten . . . . . . . . . . . . . . . . . . . . . 13.4.10 Parametersatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

264 264 265 269 269 271 271 272 273 274 274 278 280 287 291 292 293 295 299 302


X   Inhalt

13.4.11 Unterbrechungsbereich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.12 Exception-Handler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.13 Aktivitätsbereich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.14 Strukturierte Knoten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.15 Mengenverarbeitungsbereich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.16 Schleifenknoten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.17 Entscheidungsknoten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

304 306 308 311 312 317 322

14 Zustandsautomat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329 14.1 Überblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.2 Anwendungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.3 Anwendung im Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.3.1 Use-Cases und Zustandsautomaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.3.2 Klassen und Zustandsautomaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.3.3 Protokollzustandsautomaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4 Notationselemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.1 Einfacher Zustand. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.2 Transition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.3 Startzustand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.4 Endzustand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.5 Pseudozustände . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.6 Kreuzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.7 Entscheidung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.8 Terminator. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.9 Zusammengesetzter Zustand. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.10 Gabelung und Vereinigung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.11 Region . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.12 Ein- und Austrittspunkt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.13 Unterzustandsautomatenzustände . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.14 Historie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.15 Spezialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.16 Protokollzustandsautomat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.5 Codeabbildung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.5.1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.5.2 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.5.3 Einfache Zustandsautomaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.5.4 Erweiterungen der Zustandsautomaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.5.5 Zusammengesetzte Zustände . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

330 332 333 333 334 335 337 337 340 346 348 349 351 353 356 357 363 365 369 371 374 378 381 384 384 384 387 394 398

15 Sequenzdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401 15.1 Überblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.1.1 Modellierung von Interaktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.1.2 Interaktionen im Sequenzdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.1.3 Ursprung der Sequenzdiagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.2 Anwendungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.3 Anwendung im Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

402 403 408 411 413 414


Inhalt  XI

15.3.1 Abgrenzung des Systemkontexts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.3.2 Realisierung von Use-Cases. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.3.3 Spezifikation von Schnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.3.4 Detailmodellierung im Feindesign . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.3.5 Test und Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4 Notationselemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4.1 Interaktion / Interaktionsrahmen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4.2 Lebenslinie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4.3 Nachricht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4.4 Zustandsinvariante. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4.5 Kombiniertes Fragment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4.6 Ordnungsbeziehung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4.7 Interaktionsreferenz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4.8 Verknüpfungspunkt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4.9 Zerlegung von Lebenslinien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

16

Kommunikationsdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473

16.1 Überblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.1.1 Interaktionen in Kommunikationsdiagrammen . . . . . . . . . . . . . . . . . . . . . 16.1.2 Auswahlkriterien für das Kommunikationsdiagramm. . . . . . . . . . . . . . . . 16.2 Anwendungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.3 Anwendung im Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.3.1 (Geschäsprozess-)Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.3.2 Zusammenwirken von Classifiern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.4 Notationselemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.4.1 Interaktion / Interaktionsrahmen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.4.2 Lebenslinie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.4.3 Nachricht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

17

415 416 417 417 418 419 419 422 428 439 442 461 462 465 468

474 474 475 475 476 476 477 477 478 478 480

Timing-Diagramm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485

17.1 Überblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.1.1 Interaktionen in Timing-Diagrammen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.1.2 Auswahlkriterien für das Timing-Diagramm. . . . . . . . . . . . . . . . . . . . . . . . 17.2 Anwendungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.3 Anwendung im Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.4 Notationselemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.4.1 Interaktion / Interaktionsrahmen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.4.2 Lebenslinie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.4.3 Zeitverlaufslinie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.4.4 Nachricht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.4.5 Sprungmarke. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.4.6 Wertverlaufslinie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.4.7 Ordnungsbeziehung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

486 486 487 488 489 489 490 491 493 496 496 497 498


XII   Inhalt

18 Interaktionsübersichtsdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . 501 18.1 18.2 18.3 18.4

Überblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anwendungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anwendung im Projekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Notationselemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18.4.1 Interaktion/Interaktionsreferenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18.4.2 Kontrollelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

502 504 505 505 505 507

Teil IV: Weiterführendes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511 19 Tailoring – UML 2 Profile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513 19.1 19.2 19.3 19.4

19.5 19.6 19.7 19.8

Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einführung in Profile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anwendungsbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Notationselemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.4.1 Stereotyp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.4.2 Erweiterungsbeziehung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.4.3 Profil. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.4.4 Profilanwendung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Varianten und Beispiele. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Profile: Für & Wider . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Erstellen von Profilen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tools. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

20

SysML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533

20.1 Was ist SysML? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.1.1 Die SysML in diesem Buch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.2 SysML – UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.3 Diagramme der SysML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.3.1 Rahmen für Diagramme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.4 Strukturmodellierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.4.1 Block. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.4.2 Blockdefinitionsdiagramm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.4.3 Internes Blockdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.5 Verhaltensmodellierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.5.1 Aktivitätsdiagramm der SysML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.6 Anforderungen und Traceability mit der SysML . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.6.1 Anforderungsdiagramm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.6.2 Nachvollziehbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

514 516 517 518 518 522 524 525 529 529 530 530

534 534 535 535 536 536 537 537 538 541 541 543 543 545

Literaturverzeichnis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547 Register . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551


Vorwort

Das Buch, das Sie gerade in Händen halten, war eines der ersten – und ist immer noch eines der besten – Bücher, die erklären, wie Sie die Version 2 der Unified Modeling Language (UML 2) in realen Sowareprojekten praktisch anwenden. Seit der ersten Veröffentlichung von UML 2 glasklar im Jahr 2004 wurde die grundlegende Überarbeitung der UML 2 in den meisten kommerziellen und Open Source UML-Werkzeugen umgesetzt, und nach wie vor ist die UML 2 die Standardsprache zur Beschreibung der Architektur von sowareintensiven Anwendungen. Ihre Beliebtheit bei Sowareentwicklern grei rasch auf die Systemingenieure über, die jetzt den SysML (Systems Modeling Language)-Dialekt der UML 2 nutzen, um sowohl Hardwarekomponenten mit physikalischen Verbindungen als auch Sowarekomponenten und Informationsflüsse zu spezifizieren. Wenn man den Erfolg einer künstlichen Sprache an ihrer Umsetzung und Verwendung misst, dann ist die UML 2 eindeutig erfolgreich. Wenn man allerdings den Erfolg der UML 2 an ihrer Anwendung in Sowareprojekten misst, die „in der Zeit und unter dem Budget“ liegen, dann erzielt die UML 2 nur gemischte Resultate. Einerseits machen mir die zahlreichen Projekte Mut, die UML-2-Modellierungstechniken systematisch anwenden, um die Präzision und die Qualität ihrer Unternehmensarchitekturen und -prozesse zu verbessern. Andererseits bin ich entsetzt über die Vielzahl von Projekten, die sich mit „Use Case Abuse“ (Use CaseMissbrauch), „Snake Oil Architecture“ (Wunderarchitekturen) und anderen „Worst Practices“ in der Modellierung herumschlagen. Leider gehört es für viele Sowareentwickler immer noch zum Alltag, gewaltige Mengen von lose verbundenen Kästchen-und-Linien-Zeichnungen zu erzeugen, anstatt präzise Architekturpläne zu erstellen. Warum ist die UML 2 so schwer zu beherrschen und anzuwenden? Dafür gibt es zwei Hauptgründe. Erstens gehört zum Beherrschen jeder neuen Sprache, ob künstlich oder natürlich, eine steile Lernkurve. Es kostet viel Zeit und Mühe zu lernen, wie man mehrdeutige natürlichsprachige Anforderungen in präzise „Kästchen und Linien“ übersetzt, die potenziell Sowarecode erzeugen können. Zweitens ist es weit schwieriger, die Strukturen und die Komplexität von Sowarearchitekturen zu beherrschen als die Sprache, mit der sie beschrieben werden. Das „Soware-Paradox“ kann es in Bezug auf die Dialektik mit dem Lügner-Paradox des ersten Jahrtausends v. Chr. aufnehmen, und die „Sowarekrise“ kommt in Bezug auf die „Byzantinische Komplexität“ der Finanzkrise des dritten Jahrtausends n. Chr. gleich. Sowareprojekte leiden weiter unter den seuchenartigen Antipattern „Requirements Creep & Churn“ (Erschleichung weiterer Anforderungen) und „System Sprawl“ (Systemzersiedelung), und Entwickler kämpfen weiterhin mit der Wahl zwischen anorektischen Agilen Prozessen und bulimischen strikten Prozessen. Ist UML 2 eine Universallösung, um Sowarearchitekturen zu beherrschen? Natürlich nicht, aber sie ist ein Schlüsselelement einer umfassenderen modellbasierten Lösung, welche die synergistische Kombination von modellbasierten Sprachen, Prozessen, Frameworks


XIV   Vorwort

und Werkzeugen benötigt. Wenn Sie also ein guter Sowarearchitekt sind oder werden wollen, ist Zeit, in der Sie die beste momentan verfügbare Sprache zur Beschreibung von Sowarearchitekturen erlernen, gut angelegt. Ich lege Ihnen sehr ans Herz, Ihre Kenntnisse der UML 2 weiter zu vertiefen, um Ihre Unternehmensarchitekturen und -prozesse zu verbessern. Die Lernkurve für UML 2 ist zwar steil, dieses praxisorientierte Anwendungsbuch wird sie aber wesentlich verkleinern, so dass Sie den Lohn für Ihre Mühen bereits früh ernten können. Cris Kobryn Vorsitzender der Submission-Teams der UML-Partner, der UML2-Partner und der SysML-Partner Gründer & Geschäsführer, PivotPoint Technology Corporation


Einleitung

■ Liebe Leserin, lieber Leser, Es ist so weit, die neue, überarbeitete Auflage unseres Werkes liegt in Ihren Händen. Warum gibt es eine vierte Auflage? Im April 2005 hat die OMG den neuen Standard UML 2.0 offiziell verabschiedet und im August 2011 nun die Version 2.4 herausgegeben. Dieser Aktualisierung sind wir gefolgt und haben eine neue Auflage unseres Buches erstellt. Die damit einhergegangenen Änderungen stellen jedoch nur einen Teil der Neuerungen der vierten Auflage dar. Wir haben den praktischen Einsatz der UML weiter ausgebaut und uns stärker auf den Einsatz der UML in der Analysephase zur Formulierung von Anforderungen an Ihr System konzentriert. Überzeugen Sie sich aber selbst davon und lesen Sie weiter! Bei der Komplexität heutiger Soware-Systeme ist eine grundlegende Analyse- und Designphase nahezu unumgänglich. Doch was hil die beste Planung ohne adäquate Möglichkeit, die Ergebnisse übersichtlich und dennoch präzise auszudrücken und darzustellen? Die Unified Modeling Language (UML) bietet eine solche Möglichkeit – und gewiss nicht die allerschlechteste, wie ihr schneller Erfolg beweist (Kapitel 1). Heute ist die UML als effektives Werkzeug aus der Soware-Entwicklung nicht mehr wegzudenken. Eine ihrer größten Stärken besteht sicherlich in der breiten Einsatzmöglichkeit: Von der Analyse bis zum Test bietet sie jedem Projektbeteiligten eine Fülle an Notationselementen. Damit Sie bei dieser Vielfalt nicht den Überblick verlieren, können Sie in Abbildung 1 auf einen Blick erkennen, welche Aspekte der UML Sie in welchem Kapitel finden.

Allheilmittel UML


XVI   Einleitung

UML 2 glasklar Einleitung Teil I Einführung

Teil II Strukturdiagramme

1. Einführung und Historie

Teil III Verhaltensmodellierung

6. Klassendiagramm

12. Use-Case-Diagramm

Teil IV Weiterführendes 19. Tailoring der UML

Projekt UML

2.Vorgehen

7. Paketdiagramm

3. Allgemeine Grundkonzepte

8. Objektdiagramm

13. Aktivitätsdiagramm

20. SysML

14. Zustandsautomat

hh

hh

4. Analyse mit der UML

9. Kompositionsstrukturdiagramm

15. Sequenzdiagramm

5. Die UML in der Realisierung

10. Komponentendiagramm

16. Kommunikationsdiagramm

11. Verteilungsdiagramm

17. Timing-Diagramm

18. Interaktionsübersichtsdiagramm

Literaturverzeichnis Index

Gliederung des Buches

ABBILDUNG 1 Die Gliederung: Das Buch ist in vier große Abschnitte unterteilt, die jeweils unterschied-

liche Teilaspekte der UML beleuchten: (I) Allgemeine Einführung und Verwendung der UML, (II) Beschreibung der Strukturdiagramme, (III) Beschreibung von Diagrammen für die Verhaltensmodellierung und (IV) Die Anpassungsmöglichkeiten der UML und die SysML.


Einleitung  XVII

Wer dieses Buch aus welchem Grund lesen sollte Warum sollten Sie Ihre wertvolle Zeit mit diesem Buch verbringen? Weil Sie hier viele Antworten und Beispiele finden, die erläutern, wie Sie die UML – auf dem aktuellsten Stand – erfolgreich in Ihren Projekten nutzen können.

Theorie & Best Practices

Es vermittelt Ihnen fundierte Kenntnisse in der UML 2: zum einen natürlich Begriffe und Notation, zum anderen aber auch die Anwendungsmöglichkeiten im Projekt. Zu jedem Diagramm finden Sie Vorschläge für den sinnvollen praktischen Einsatz. Das Buch richtet sich gleichermaßen an den UML-Neuling, der eine schrittweise Einführung in die Basiselemente jenseits aller Versionierungen erwartet, wie an den erfahrenen UML-Anwender, dem vielleicht eher an einer übersichtlichen Darstellung der Notationsmittel der UML 2 als Nachschlagewerk gelegen ist. Ist die Zertifizierung UML Professional für Sie interessant, versäumen Sie es nicht, ergänzend zu den Inhalten in diesem Buch auf unseren Webseiten www.uml-glasklar.com die Erläuterungen, Übungsaufgaben und deren Lösung zur Prüfungsvorbereitung zu nutzen. In der 1. Auflage hatten wir uns bemüht – soweit dies sinnvoll war –, für alle verwendeten Begriffe eine geeignete deutsche Übersetzung zu finden und sie anzuwenden. Durch die Veröffentlichung dieser Begriffe in einem kompakten Glossar auf der Webseite zu diesem Buch, www.uml-glasklar.com, haben sich unsere Übersetzungen mittlerweile im deutschsprachigen Raum als Standard durchgesetzt. Haben Sie dazu noch weitere oder andere Begriffsvorschläge, schreiben Sie uns eine Mail: buch@uml-glasklar.com.

UML-Glossar

Zum Aufbau der Kapitel in Teil II und Teil III: Zu Beginn jedes Kapitels wird Ihnen im Überblick das jeweilige Diagramm kurz vorstellt. Das Anwendungsbeispiel zeigt das Diagramm und dessen Notationselemente im Einsatz. Unter Anwendung im Projekt schildern wir sinnvolle Einsatzmöglichkeiten und geben Ihnen Tipps für die Praxis. Anschließend werden die einzelnen Notationselemente des Diagramms beschrieben und mit Hilfe von Beispielen erklärt. Dabei ziehen wir, sofern es uns sinnvoll erscheint, sofort Parallelen zur programmiersprachlichen Umsetzung, um die konkreten Auswirkungen der Modellierung zu verdeutlichen. Wir haben uns bemüht, zusammengehörige Informationen auch kompakt darzustellen. Aufgrund der Komplexität des Themas ist es aber mitunter nötig, im Text andere Kapitel des Buches zu referenzieren. In diesem Fall verweist Sie ein Piktogramm mit einer Kapitelnummer an jene Stelle im Buch, an der Sie weiterführende oder Hintergrundinformationen finden. Wo es uns sinnvoll erschien, haben wir Ihnen Detailinformationen zu bestimmten Themen in einer Infobox zusammengestellt. Zudem beschreiben einige Spezialisten in den so genannten Expertenboxen ihre spezifischen Erfahrungen mit der UML. Dieses Piktogramm weist auf fachliche Inhalte hin, die geeignet sind, sich für die Prüfung zum Certified Professional für Requirements Engineering – Advanced Level Requirements Modeling des International Requirements Engineering Boards (IREB) e. V. gezielt vorzubereiten. Den entsprechenden Lehrplan für dieses Zertifikat finden Sie auf der Webseite http://www.certified-re.de/lehrplaene/advanced-level.html. An der Ausarbeitung dieses Lehrplanes, der Prüfungsordnung und der Prüfungsfragen war Dr. Stefan Queins intensiv beteiligt. Die fachlichen Inhalte dieses Buches beziehen sich auf die aktuelle Lehrplanversion 1.0 vom 1. März 2011.

Ö 3.4.2


XVIII   Einleitung

Die Rechte an diesem Advanced Level Lehrplan Requirements Modelling liegen in den Händen des IREB e. V.. Der Lehrplan kann im Zuge der nächsten Jahre geändert werden – daher sollten Sie für die Prüfungsvorbereitung immer die aktuellen Dokumentenstände des Lehrplanes und der Prüfungsordnung auf der IREB-Webseite studieren. Wir denken aber, mit diesem Buch – insbesondere mit den hervorgehobenen Stellen – einen wichtigen Beitrag für die Prüfungsvorbereitung leisten zu können. Auf Änderungen des Lehrplanes reagieren wir mit Hinweisen auf der Webseite www.uml-glasklar.com. Inhalte, die nichts mit der UML zu tun haben, aber dennoch Lehrplanstoff des Advanced Level Requirements Modeling des IREB e. V. sind, versuchen wir durch Artikel in unserem Downloadbereich abzudecken. Die relevanten Informationen finden sie unter www.uml-glasklar.com. Aktuelle Infos im Web

z. B. [3-2] für den 2ten Link in Kapitel 3

An einigen Stellen des Buches verweisen wir darauf, dass weiterführende Informationen auf unserer Web-Seite zu finden sind, und zwar dort, wo wir Ihnen ständig aktualisierte Informationen anbieten möchten, wo wir Ihnen das Abtippen von Texten ersparen wollen oder wo die Detailinformationen den Fokus oder Umfang des Buches gesprengt hätten. Die Verweise sind mit Linknummern versehen worden, die es Ihnen erleichtern, Informationen über spezielle Themen auf unserer Webseite wiederzufinden. Besuchen Sie uns doch einmal auf unserer Webseite www.uml-glasklar.com.

■ Ihre Meinung ist uns sehr wichtig Wir wollen Feedback!

Nach monatelangem Wühlen in Spezifikationen, nächtelangen Diskussionen und dem Erfinden neuer Beispiele sind wir nun auf Ihre Reaktionen gespannt. Ihre Meinung zu unserem Buch ist uns sehr wichtig. Deshalb freuen wir uns auf Ihre Eindrücke und Verbesserungsvorschläge, Ihre Kritik – aber natürlich auch Ihr Lob. Unsere E-Mail-Adresse: buch@uml-glasklar.com.

■ Danksagungen Danke, danke, danke, ...

Die Liste der Kollegen und Freunde, die alle etwas zum Buch beigetragen haben (Kaffee kochen, Hand auflegen, Grafiken zurechtbiegen, Nerven beruhigen, für fachliche Diskussionen in schlaflosen Nächten zur Verfügung stehen), ist lang – zu lang, um sie alle namentlich zu nennen. Deshalb geht unser hier veröffentlichter Dank nur an einige besonders wichtige Menschen. Vor allem an unseren Ghostwriter und Beraterkollegen Carsten Pflug, der auch diesmal wieder viele wichtige Beiträge geleistet hat. Ohne dich wäre das Buch nur halb so gut! Und natürlich auch wieder an unsere Lektorin Margarete Metzger für die vielen wertvollen Hinweise und an Cris Kobryn für die freundlichen, einleitenden Worte. Dank auch an die Kollegen, die uns wichtige Impulse gaben und mit den hier zitierten Beiträgen in den Expertenboxen das Themengebiet sehr gelungen abrunden. Unsere Zusammenarbeit mit Euch zeigt, dass ein Netzwerk viel mehr leisten kann als eine Einzelperson. Danke an: Branislav Selic (IBM), Michael Stal, Marko Boger (Gentleware) und Morgan Björkander (Telelogic).


Einleitung  XIX

■ Die Autoren An dieser Stelle möchten wir unseres Freundes, Weggefährten und Geschäspartners Mario Jeckle gedenken. Bei dem Versuch, Unfallopfern zu helfen, ist Mario vor einigen Jahren zu Tode gekommen. Mario hatte noch viel vor – er war engagiert in der Forschung, für seine Studenten, plante zahlreiche Veröffentlichungen, Konferenzen und Interviews. Aber Mario hat auch beeindruckende Spuren hinterlassen, wie z. B. dieses Buch, dessen Idee bei einem Treffen zwischen ihm und Chris Rupp auf der OOP 2003 in München entstand. Der Erfolg der ersten Auflage hat uns ermutigt, weiterzumachen und dazu beizutragen, dass Marios visionäre Ideen weiterleben. Obwohl wir Mario aus rechtlichen Gründen nicht mehr als Autor dieses Buches nennen dürfen, sehen wir ihn doch immer noch als Teil dieses Werkes, da, obschon er nur an der ersten Auflage aktiv beteiligt war, wir immer noch seine Spuren in diesem Buch erkennen können. Ein weiterer Dank geht an Barbara Rudolph. Auch sie hat die frühen Ausgaben dieses Werkes signifikant mitgestaltet. Ihr beruflich stressiger Alltag erlaubte es ihr leider irgendwann nicht mehr, so viel Zeit und Energie in ein Buchprojekt wie dieses zu investieren. Chris Rupp (chris.rupp@sophist.de), OberSOPHISTin oder, formal ausgedrückt, geschäsführende Gesellschaerin der SOPHIST GmbH und der SOPHIST Technologie GmbH. In 20 Jahren Berufstätigkeit sammelt sich so einiges an ... ein Unternehmen ... 6 Bücher ... 40 Mitarbeiter ... und unheimlich viel Erfahrung. Meine Leidenscha für die Projektberatung ist vermutlich schuld daran, dass ich bis heute nicht „nur“ manage, verwalte und Menschen fördere, sondern auch ganz nah am Kunden dran bin, in Projekten maßgeblich mitarbeite, sie leite. Vielleicht rettet mich hier immer wieder das Talent, die richtigen Mitarbeiter um mich zu scharen. Gute Ideen so umzusetzen, dass Entwickler, Vertragspartner, direkt und indirekt betroffene Anwender das Gefühl haben, ein intelligentes, durchdachtes und nutzbringendes Produkt vor sich zu haben, ist die Vision, die mich dabei antreibt. Private Vorlieben (zu viele für zu wenig Zeit): Menschen, Philosophie, Rotwein, Reisen, Sport und die Suche nach dem Sinn des Lebens. Dr. Stefan Queins (stefan.queins@sophist.de): Während meiner Promotion in der Informatik in Kaiserslautern lernte ich Chris kennen, die mich dann nach meinem Abschluss nach Nürnberg zu den SOPHISTen lockte. Hätte ich vorher gewusst, was auf mich zukommt ... ich hätte mich nicht anders entschieden. Ob es sich bei meiner Arbeit um die Methodik der Systembeschreibung eines Infotainment-Systems oder um die Architektur einer Soware zur Unterstützung der nächsten Bundestagswahl handelt: die Vielfalt meiner Aufgabenstellungen und Anwendungsbereiche macht für mich die Arbeit als Berater und Trainer so interessant. Und nicht zuletzt die Komponente Mensch, die jedes Projekt speziell und einzigartig macht. Aber so ganz kann ich die Forschung auch nicht lassen. Bei SOPHIST bin ich verantwortlich für das Management von Innovationen, also die Entwicklung neuer, praxisbezogener Ideen und Verbesserungen interner Prozesse.

Nachruf für Mario Jeckle


XX   Einleitung

Neben meiner Arbeit komme ich zur Zeit leider nicht mehr zu meiner liebsten Freizeitbeschäigung, dem Reiten. Dafür verbringe ich jetzt mehr Zeit mit Segeln und damit, gemütlich abends beim Essen zusammen zu sitzen. Und das mit einer guten Flasche Rotwein und netten Gesprächen über „Gott und die Welt“. Die SOPHISTen: Damit ein Buch wie dieses entsteht, müssen viele Kollegen an einer Idee mitwirken. Neben uns beiden Hauptautoren gab es helfende Hände und Köpfe, die Grafiken zauberten, Feedbacks gaben, Korrektur gelesen haben, Ideen geliefert haben und für Diskussionen zur Verfügung standen. Nicht zu vergessen sind auch all die Kollegen, die für die Vermarktung dieses Werkes, der Präsentation im Internet und der Bewältigung der Kommunikation mit den Lesern bereit stehen. Da es sich hier um SOPHISTen gehandelt hat, steht das Logo statt eines Fotos stellvertretend für all unsere Kollegen.


12

Use-Case-Diagramm

Die Frage „Was soll mein geplantes System eigentlich leisten?“ sollte am Beginn jeder Systementwicklung stehen. Eine fundierte Beantwortung dieser Frage bewahrt Sie davor, im Detail zu versinken, bevor Sie wissen, was vom System überhaupt erwartet wird. Ein Use-Case-Diagramm (dt. Anwendungsfall-Diagramm) zeigt das externe Verhalten eines Systems aus der Sicht der Nutzer, indem es die Nutzer (im UML-Jargon „Akteure“ genannt), die Use-Cases und deren Beziehungen zueinander darstellt. Ein Nutzer kann eine Person, aber auch ein Nachbarsystem sein. Use-Cases bilden die Reaktion des Systems auf Ereignisse seiner Umwelt ab und fassen dabei Teile der Systemdienstleistung zusammen.

Die externe Nutzersicht


242  12 Use-Case-Diagramm

■ 12.1 Überblick 12.1.1 Die Use-Case-Analyse Systemdienstleistungen von außen betrachtet

Die im Rahmen einer Use-Case-Analyse erstellten Use-Case-Diagramme zeigen das nach außen sichtbare Verhalten eines Elements. Diese Elemente werden in der UML 2 formal als Gegenstand (subject) bezeichnet und stellen in der Regel komplette (Hardware- bzw. Soware-)Systeme oder Subsysteme dar. Genauso gut können Sie damit aber auch das externe Verhalten von Klassen, Schnittstellen, Komponenten oder Knoten modellieren. Trotzdem verwenden wir im weiteren Verlauf des Kapitels den Begriff „System“ und zeigen Beispiele für weitere mögliche Elemente, die externes Verhalten realisieren.2

Kapselung

Ein Use-Case (dt. Anwendungsfall) selbst kapselt eine in sich geschlossene Sammlung von Aktionen, die in einer spezifizierten Reihenfolge ablaufen. Er stellt somit seiner Umwelt eine Dienstleistung, sprich: ein Verhalten zur Verfügung. Denken Sie an einen Web-Browser. Dieses System bietet Ihnen als Dienstleistung (als Use-Case) die Möglichkeit, „eine Webseite anzuzeigen“ oder „die Webseite zu drucken“. Oder nehmen Sie als Beispiel für einen Knoten (Abschnitt 11.4.1) einen Fileserver, der die Use-Cases „Verzeichnis anzeigen“, „Datei Up- und Download“ oder „Nutzer authentifizieren“ realisiert. Im Projekt sollten Sie das Verhalten eines Use-Cases mittels einer Use-Case-Beschreibung detaillieren. Da diese Use-Case-Beschreibung aber kein UML-Notationsmittel ist, sondern rein textuell erstellt wird, betrachten wir sie in diesem Kapitel nicht detaillierter. Informationen zu unterschiedlichen Schablonen für Use-Case-Beschreibungen finden Sie auf unseren Webseiten.

Knoten 11.4.1

Ö

Was statt wie

Sehen wir uns das Beispiel Web-Browser und den Use-Case „Webseite anzeigen“ näher an: Er umfasst den Auslöser (Initiator) des Use-Cases, die einzelnen Schritte (z. B. „Webadresse eingeben“ oder „Serveranfrage starten“, aber auch Sonder- und Fehlerfälle, z. B. die Eingabe einer unvollständigen Webadresse) und daran beteiligte externe Personen und Systeme, die so genannten Akteure. Ein Use-Case zeigt aber nicht, welche Klassen und Operationen an den Aktionen beteiligt sind. Er gibt auch keine Auskun darüber, wie die Webseite für die Anzeige im Bildspeicher aufgebaut wird.

Akteure sind externe Kommunikationspartner

Der Akteur ist externer Kommunikationspartner des Use-Cases. Während des Ablaufs eines Use-Cases liefert oder empfängt der Akteur Signale bzw. Daten zum oder vom System, das den Use-Case realisiert. Typische Akteure unseres Web-Browsers sind der Internetsurfer bzw. das Betriebssystem als Schnittstelle für die Netzwerkübertragung oder zum Dateisystem. Ein Use-Case-Ablauf ist ein zeitlich in sich abgeschlossener Vorgang mit einem Auslöser (Webseite angefordert) und einem Ergebnis (Webseite angezeigt). Ein Akteur initiiert einen Use-Case, der das Ergebnis entweder an den gleichen oder einen anderen Akteur liefert. Zur Ablaufzeit interagiert eine Instanz des Akteurs mit einer Instanz des Use-Cases.

Malen nach Zahlen?

Im Gegensatz zu vielen anderen UML-Diagrammen sind Use-Case-Diagramme – auch bedingt durch eine sehr begrenzte Anzahl an Notationselementen – eingängig und übersichtlich. Glücklicherweise wurde daran auch in der UML 2 nichts Signifikantes verändert. Use-CaseModellierung mag auf den ersten Blick trivial, wie „Malen-nach-Zahlen“, aussehen. 2

Realisieren ist hier im allgemeinen Sinn der Zuordnung zu verstehen und nicht in der engeren Auslegung als „Realization“-Beziehung (Abschnitt 6.4.13).


12.1 Überblick  243

In der Projektrealität tri man häufig eine sehr einfache, skizzenhae Verwendung von Use-Case-Diagrammen für erste Diskussionen mit den Stakeholdern an, die es Ihnen ermöglicht, Besprochenes in ein Bild zu fassen. Gerade im technischen Projektumfeld werden Use-Case-Diagramme aber auch etwas formaler zu einer ersten Kontextabgrenzung eingesetzt. Dort werden die einzelnen Ereignisse, die die Systemgrenze passieren, systematisch erhoben, notiert und ausgewertet. Erinnern Sie sich beim Einsatz von Use-Case-Diagrammen immer wieder daran, dass Sie ganz am Beginn einer Systementwicklung stehen und nicht jedes Detail in diesem Diagramm unterbringen müssen – die UML bietet Ihnen noch ein paar mehr Diagrammarten an. Ein Use-Case-Diagramm enthält die grafische Darstellung

Notationsmittel

ƒ des Systems, ƒ der Use-Cases, ƒ der Akteure außerhalb des Systems, ƒ der Beziehungen zwischen Akteur und Use-Case, oder Use-Cases untereinander sowie ƒ Generalisierungen von Akteuren.

Akteur

Systemname

Online-Banking-System Berechtigung prüfen Webseite anzeigen

«include» IncludeBeziehung

extension points Ausdruck

«extend»

Kontostand drucken

Bankkunde Kontostand anzeigen Assoziation Systemgrenze

Extend-Beziehung

Use-Case

ABBILDUNG 12.1 Ein Use-Case-Diagramm und seine Bestandteile

12.1.2 Ursprung von Use-Cases Die Idee der Use-Cases, nämlich die Beschreibung des funktionalen Verhaltens eines Systems von außen gesehen, geht bereits auf die späten 70er und frühen 80er Jahre zurück [MPa84]. Populär und letztendlich in die UML eingeführt wurden sie durch Ivar Jacobson, der die Use-Cases als eine Haupttechnik in der Systemanalyse nutzte [Jac92]. Seit Mitte der 90er Jahre etablierte sich diese Art der Analyse in abgewandelter Form als fester Bestandteil in zahlreichen Vorgehensmodellen (siehe zum Beispiel [Kru00]). Für den tieferen Einstieg in die allgemeine Methodik der Use-Case-Analyse empfehlen sich [Coc98] oder [Arm00], für die Anwendung bei der Entwicklung technischer Systeme [HRu02].

Use-Case-Väter


244  12 Use-Case-Diagramm

UML 2 Schönheitskorrekturen und Klarstellungen

Die UML ermöglicht die Use-Case-Modellierung seit der ersten Version. Außer einigen kleinen Schönheitskorrekturen hat sich auch in der UML 2 nichts an den Use-Case-Diagrammen geändert. Explizit herausgearbeitet wird im neuen Standard jedoch die Möglichkeit, dass beliebige Classifier (also auch explizit Klassen, Schnittstellen, Komponenten, …) UseCases realisieren können. Obwohl dies auch in älteren Versionen nicht verboten war, wurde in der Praxis kaum Gebrauch davon gemacht. Meist wird die Use-Case-Analyse für die Beschreibung eines kompletten Systems verwendet. Abstrakt betrachtet ist ein Use-Case jedoch nur die Repräsentation eines Verhaltens, das einem Nutzer angeboten wird. Wer den Use-Case realisiert bzw. dieses Verhalten anbietet, ist in der Use-Case-Analyse nur zweitrangig. Seit dem Update auf UML 2 gehören Use-Case-Diagramme daher auch nicht mehr zu den (statischen) Strukturdiagrammen, sondern zu den (dynamischen) Verhaltensdiagrammen.

■ 12.2 Anwendungsbeispiel Das Anwendungsbeispiel zeigt, dass das System, das die Use-Cases realisiert, nicht zwangsläufig aus Hard- oder Soware besteht. Die Modellierung der „realen Welt“ und von Geschäsprozessen mittels Use-Cases ist ebenso möglich wie die Darstellung von technischen Systemprozessen in Echtzeitsystemen.

(LQZHLKXQJVIHLHU ©9RUEHGLQJXQJª ^.KOVFKUDQNJHSOQGHUW`

7DQ]HQ H[WHQVLRQSRLQWV 1DFKVFKXE 7ULQNHQ *DVW

8QWHUKDOWHQ

H[WHQVLRQSRLQWV 1DFKVFKXE

©H[WHQGª 1DFKVFKXERUGHUQ ©H[WHQGª

(VVHQ

)HLHUDXIO|VHQ ©LQFOXGHª *lVWH KLQDXVEHJOHLWHQ

©LQFOXGHª

)HLHUDEUXSWEHHQGHQ

*DVWJHEHU

ABBILDUNG 12.2 Die wichtigsten Use-Cases einer Einweihungsfeier

3ROL]HL


12.3 Anwendung im Projekt  245

■ 12.3 Anwendung im Projekt 12.3.1 Typische Anwendungsbereiche Use-Case-Diagramme ermöglichen eine „Black Box“-Sicht auf das betrachtete System. Damit können Sie anwendernah und unabhängig von internen technischen Abläufen das System von seiner Umwelt abgrenzen und die elementaren Systemanforderungen finden. Modellieren Sie Use-Cases, wenn Sie

Fokus: „Black Box“-Sicht

ƒ die funktionalen Dienstleistungen eines Systems oder einer Komponente „auf einen Blick“ zeigen wollen; ƒ Ihr System aus der Nutzersicht in handhabbare, logische Teile zerlegen wollen; ƒ die Außenschnittstellen und Kommunikationspartner des Systems modellieren möchten; ƒ komplexe Systeme leicht verständlich und auf hohem Abstraktionsniveau darstellen möchten oder ƒ planbare Einheiten, das heißt Inkremente, für Ihre Entwicklung benötigen. Sie sollten Use-Case-Diagramme vor allem in der Anforderungsanalyse einsetzen. Weil sie leicht verständlich sind, bieten sie eine gute Grundlage für die Kommunikation zwischen Anwendern, Entwicklern und Analytikern. Sie verschaffen Ihnen einen Überblick über das System und seine Einbettung in einen größeren Kontext. Gerade die Darstellung der beteiligten Akteure und der Systemgrenzen liefert essenzielle Informationen für die weitere Systementwicklung. Sie bewahrt Sie vor bösen Überraschungen und legt von Anfang an fest, was zu Ihrem System gehört und was nicht, was Sie entwickeln (Kosten!) und welchen Schnittstellen Sie gerecht werden müssen (Anforderungen!).

Multitalent in der Anforderungsanalyse

Use-Case-Diagramme bieten sich vor allem in frühen Phasen eines Projektes oder bei der Entwicklung neuer oder erweiterter Komponenten an. Mit Hilfe von Use-Cases können Sie die Entwicklung eines Systems oder einer Komponente planen. Dieses Use-Case-getriebene Vorgehen ist eine geeignete Basis für eine inkrementelle Systementwicklung. Ein Use-Case kann dabei einem Inkrement entsprechen, das der Reihe nach priorisiert, analysiert, entworfen, implementiert und getestet wird.

Planung und Inkrementbildung

12.3.2 Use-Cases und danach? Natürlich ist es nicht damit getan, ein Use-Case-Diagramm zu zeichnen (wobei der Aufwand für das Finden aller Akteure, das richtige Schneiden der Use-Cases und die Festlegung der Systemgrenzen nicht zu unterschätzen ist!). Use-Cases sind erst dann „vollständig“, wenn die dahinter stehenden Abläufe beschrieben sind. Je nach deren Natur, dem Zweck der Dokumentation und dem Zielpublikum sollten Sie unterschiedliche Mittel zur Beschreibung der Use-Cases, genauer der Use-Case-Abläufe, einsetzen. Tabelle 12.1 gibt Ihnen hierfür eine Entscheidungsgrundlage. Unabhängig von ihrer Art sollte eine Use-Case-Beschreibung den Namen des Use-Cases, die Ablaufbeschreibungen, zugehörige Akteure, Vorbedingungen, Nachbedingungen und


246  12 Use-Case-Diagramm

Ö 13–16, 18

TABELLE 12.1 Beschreibungsmöglichkeiten für Use-Cases

Merkmale des Use-Case

Empfohlene Notation zur Use-Case-Beschreibung

Referenz

Kurze klare Abläufe, wenige Sonderfälle

(Strukturierter) Text

Ablauf- oder schrittorientiert (1., 2., …)

Aktivitätsdiagramm

Kapitel 13

Einfache daten- oder entitätsorientierte Abläufe (viele Entitäten)

Kommunikationsdiagramm

Kapitel 16

Komplexe daten- oder entitätsorientierte Abläufe (viele Entitäten)

Sequenzdiagramm

Kapitel 15

Kein „typischer“ Ablauf, gleichwahrscheinliches Aureten von Abfolgen und Ereignissen

Zustandsautomat

Kapitel 14

Use-Case bündelt viele Szenarien

Interaktionsübersichtsdiagramm Kapitel 18

Ausnahmen enthalten. Ein Beispiel einer derartigen Use-Case-Beschreibung finden Sie auf unserer Homepage www.uml-glasklar.com [12-1]. [Coc98] diskutiert zudem unterschiedliche Möglichkeiten und Schablonen, natürlich-sprachlich beschriebene Use-Case-Abläufe zu strukturieren. Erweiterte Beschreibungsschablonen, die auch die nichtfunktionalen Aspekte des Systems berücksichtigen und daher auch für eher technisch orientierte Systeme geeignet sind, bieten [HRu02] und www.sophist.de an.

■ 12.4 Notationselemente 12.4.1 Use-Case Definition A use case is the specification of a set of actions performed by a system, which yields an observable result that is, typically, of value for one or more actors or other stakeholders of the system.

Notation Notation

In aller Regel wird ein Use-Case durch eine Ellipse dargestellt. Der Name des Use-Cases wird dabei inner- oder unterhalb der Ellipse notiert.

8VH&DVH1DPH 8VH&DVH1DPH

ABBILDUNG 12.3 Die Standardnotationen für einen Use-Case


12.4 Notationselemente  247

Beschreibung Ein Use-Case beschreibt eine Menge von Aktionen, die, schrittweise ausgeführt, ein spezielles Verhalten formen. So umfasst z. B. der Use-Case „Datei speichern“ alle Aktionen, die nötig sind, um eine Datei auf einem Medium abzulegen. Also etwa die Aktionen Menüpunkt anklicken, Verzeichnis auswählen, Dateiname vergeben und mit OK bestätigen. Ein Use-Case bildet eine Art Hülle, die auch Sonder- und Fehlerfallaktionen einschließen kann (denken Sie daran, dass der Speicherplatz erschöp sein bzw. der vergebene Dateiname unzulässige Zeichen enthalten kann).

Use-Case = Hülle für Standard-, Sonder-, Fehlerfall

Ein Use-Case wird stets von einem Akteur ausgelöst bzw. instanziiert (Trigger: „Menüpunkt anklicken“) und führt zu einem fachlichen Ergebnis (Datei auf dem Medium abgelegt). Die Bezeichnung des Use-Case spiegelt die Sicht des Akteurs wider (z. B. „Film ausleihen“) und nicht die des Systems (müsste dann ja „Film verleihen“ heißen). Ein Use-Case darf auch gleichzeitig mehrfach instanziiert werden (gleichzeitiges Abspeichern von mehreren Dateien). Unterschiedliche Use-Cases sind parallel instanziierbar (Datei speichern, Datei drucken, Datei kopieren, …). D. h., auch wenn Sie in einem Diagramm nur fünf Use-Cases sehen, können Hunderte von realen Abläufen gleichzeitig durch das System abgewickelt werden.

Mehrfache Instanziierung

Anfrage/Trigger

Ergebnis

Akteur

Ausführung der Anfrage Use-Case

ABBILDUNG 12.4 Ausführung eines Use-Case

Betrachten Sie Use-Cases immer als abgeschlossene Einheiten, die ein funktionales Verhalten widerspiegeln und bei denen interne Strukturen irrelevant sind. Der Fokus liegt auf der an der Schnittstelle angebotenen Dienstleistung – welche Daten oder Zustände manipuliert werden, sieht der Nutzer eines Use-Cases nicht. Ihn interessiert nur der Auslöser eines Use-Case-Ablaufs, die Kommunikation (Interaktion oder Kollaboration, „Wer muss wann was liefern?“) zwischen Akteuren und Use-Cases und das am Ende stehende Ergebnis. Ein Use-Case-Ablauf ist dann zu Ende, wenn keine Kommunikation zwischen Akteur und Use-Case mehr erfolgt – mit anderen Worten: wenn der Ablauf „zur Ruhe gekommen“ ist. Neben der Modellierung von einzelnen, autarken Use-Cases dürfen Sie Use-Cases auch in Beziehung zueinander setzen. Dadurch verknüpfen Sie die Abläufe der einzelnen Use-Cases zu einem Ablauf.

Beziehungsgeflechte

Abbildung 12.5 zeigt den Basis-Use-Case Standardauthentifizierung, der eine Aktionsfolge mit der Texteingabe von Benutzername und Passwort vorsieht. Moderne Authentifizierungsverfahren ermöglichen aber auch technische Varianten dieses Ablaufs: Authentifzierung mittels Fingerabdruck oder per Chipkarte. Die zugehörigen Abläufe sind entsprechend in den spezialisierten Use-Cases überschrieben. Beachten Sie, dass sich zusätzlich zum Verhalten auch die Beziehungen zu Akteuren vererben.

Generalisierung und Spezialisierung


248  12 Use-Case-Diagramm

Standardauthentifizierung

Chipkartenauthentifizierung

Benutzer 1. Authentifizierung starten 2. Chipkarte durchziehen 3. Chip ID verifizieren 4. -

1. Authentifizierung starten 2. Benutzername eingeben 3. Identifizierung starten 4. Identifizierung bestätigen

Fingerabdruckauthentifizierung

1. Authentifizierung starten 2. Benutzername eingeben 3. Fingerabdruck scannen 4. -

ABBILDUNG 12.5 Eine Generalisierungsbeziehung zwischen Use-Cases. Die Kommentare verdeutlichen

die Einzelschritte.

Ö 12.4.4, 12.4.5

Weitere Beziehungen zwischen Use-Cases beschreiben wir aufgrund ihres Umfangs in eigenen Unterkapiteln (Abschnitte 12.4.4, 12.4.5). Die UML gewährt Ihnen bei der Notation von Use-Cases viel Freiraum. Die verbindlichste Vorschri besteht darin, dass Sie einen Use-Case bezeichnen müssen. Für die Namensgebung bietet sich zur besseren Verständlichkeit die Form „Substantiv Verb“ oder „substantiviertes Verb“ an (zum Beispiel: „Raum buchen“, „Raumbuchung“).

Use-Case = verhaltensspezifischer Classifier

Da ein Use-Case im Metamodellsinne einen verhaltensspezifischen Classifier3 darstellt, dürfen Sie statt der üblichen Ellipsennotation auch die von Klassen bekannte Rechtecksnotation verwenden (Abschnitt 6.4.1). Die Ellipse wird dann als kleines Icon in die rechte obere Ecke des Use-Cases gesetzt.

Klassennotation 6.4.1

)LOPDXVOHLKHQ

Ö

)LOPDXVOHLKHQ

ABBILDUNG 12.6 Use-Case in Ellipsen- und Standard-Classifier-Notation

Stereotyp 19.4.1

Ö

Die Vergabe eines Stereotyps ist ebenfalls optional möglich (Abbildung 12.7). Abschnitt 19.4.1 geht detaillierter auf die Stereotypisierung ein.

©*HVFKlIWVSUR]HVVª )LOPDXVOHLKHQ

©*HVFKlIWVSUR]HVVª )LOPDXVOHLKHQ

ABBILDUNG 12.7 Stereotypisierter Use-Case

Um die Verknüpfung (engl. traceability) zwischen einem Use-Case und seiner präzisieren Verhaltensbeschreibung herzustellen, können Sie einen einzelnen Use-Case als Diagramm darstellen. Das zugeordnete Aktivitätsdiagramm wird, wie Abbildung 12.8 zeigt, in das Use-Case-Diagramm geschachtelt eingezeichnet. 3

Ein verhaltensspezifischer Classifier (Behaviored Classifier) ist ein Classifier (vgl. 3.2.5), der eine Spezifikation seines Verhaltens haben kann. Diese Spezifikation könnte zum Beispiel ein Aktivitätsdiagramm oder ein Zustandsautomat sein. Weitere Informationen zu den verhaltensspezifischen Classifiern finden Sie auf www.uml-glasklar.com, Linknummer [12-2].


12.4 Notationselemente  249

XVHFDVH Benutzerauthentifizierung Benutzerauthentifizierung

Auth. starten

Benutzername eingeben

Eingabe bestätigen

Passwort eingeben

ABBILDUNG 12.8 Detaillierte Verhaltensbeschreibung eines Use-Case

Anwendung Abbildung 12.9 zeigt die verschiedenen Notationsmöglichkeiten von Use-Cases. )LQDQ]DPW /RKQVWHXHUNDUWHEHDQWUDJHQ 6WHXHUQ]DKOHQ

6WHXHUQKLQWHU]LHKHQ

%UJHU

ABBILDUNG 12.9 Use-Cases im Rahmen eines Anwendungsbeispiels

12.4.2 System (Betrachtungsgegenstand) Definition Subject: Extending a classifier with the capability to own use cases.

Notation Das System wird als rechteckiger Kasten abgebildet, wobei die Kanten des Systems die Systemgrenzen darstellen. Der Name des Systems wird innerhalb des Kastens angegeben.

6\VWHPQDPH

ABBILDUNG 12.10 Notation für das System


250  12 Use-Case-Diagramm 6\VWHPQDPH

Beschreibung System = Classifier

6.4.1, 6.4.4, Ö 10

Das System ist diejenige Einheit, die das Verhalten, welches durch die Use-Cases beschrieben wird, realisiert und anbietet. Unter Umständen zergliedert sich das System und einzelne Bestandteile realisieren Teilaufgaben; insgesamt jedoch muss das Verhalten „nach außen“ ganzheitlich angeboten werden. Wie bereits erwähnt, ist ein System nicht die einzige Einheit, die einen Use-Case realisieren kann. Gemäß der UML-Spezifikation kann jeder Classifier einen Use-Case realisieren. Das bedeutet konkret, dass Sie in Ihren Modellen Verhalten in Form von Use-Cases insbesondere auch Klassen (Abschnitt 6.4.1), Schnittstellen (Abschnitt 6.4.4), Komponenten oder Subsystemen (Kapitel 10) zuordnen können.

Person

Essen & trinken

«component» Auftragsabwicklung

«interface» Übertragbar

Auftrag aufgeben

Adressangabe

Auftragsstatistik erstellen

Übertragungskonfiguration

Schlafen

Bewegen

.ODVVH

Auftrag anehmen

Versand

6FKQLWWVWHOOH

.RPSRQHQWH

ABBILDUNG 12.11 Eine Auswahl von Classifiern, denen Sie Use-Cases zuordnen dürfen und die diese

dann realisieren

Ö

3.2.5, 10

Kurzform der Darstellung

Der in der Praxis am häufigsten verwendete Classifier „System“ lässt sich als stereotypisierte Komponente mit dem Standardstereotyp «subsystem»4 (Kapitel 10) auffassen. Abbildung 12.12 verdeutlicht dies. Sie sehen im linken Diagramm die vollständig notierte Version eines Subsystems Tretbootverleih, während im rechten Diagramm die in der Praxis gängige Kurzform dargestellt wird. ©VXEV\VWHPª 7UHWERRWYHUOHLK

7UHWERRWYHUOHLK

ABBILDUNG 12.12 Ein System in UML ist eigentlich ein «subsystem».

4

In der UML wird das Gesamtsystem als Top-Level-Subsystem betrachtet.


12.4 Notationselemente  251

Dieses Konzept ermöglicht die Zuordnung von Use-Cases zu beliebigen Classifiern als Einheiten, die Verhalten realisieren und anbieten können. In der UML-Spezifikation sind diese Einheiten mit dem englischen Wort subject (im Deutschen etwa Betrachtungsgegenstand) bezeichnet, um zu unterstreichen, dass ein System fast alles sein kann: von einem Teil der Umwelt, in der wir leben (zum Beispiel in der Geschäsprozessanalyse: Kfz-Vermittlung, Supermarkt, …), über technische Geräte und Systeme (Waschmaschine, Autopilot, Fahrzeug, …) bis hin zu Teilsystemen oder Komponenten (Browsersoware, Datenbank, …).

Einsatzvarianten

Wir möchten Sie an dieser Stelle vor allzu extensiver Nutzung aller zulässigen Notationsmittel eines Use-Case-Diagramms warnen – auch wenn die Spezifikation dies formal zulässt. Ein Use-Case-Diagramm ist ein klassisches Analysediagramm, das den sanen Einstieg in die Systementwicklung ermöglicht, von vielen ohne tiefgreifendes UML-Wissen verstanden wird und daher vom Grundsatz her einfach gehalten werden soll.

Heimat Systemanalyse

Zur Beschreibung von Verhalten und Schnittstellen bieten sich je nach Interessensschwerpunkt bessere Notationsmittel an (Abschnitt 2.2).

UML Übersicht 2.2

Es ist im Übrigen nicht zwingend notwendig, das System zu modellieren. Ein Use-CaseDiagramm ist auch ohne Angabe der Einheit, die den Use-Case realisiert, vollständig. So haben Sie die Möglichkeit, sich zunächst auf die Verhaltensdefinition zu beschränken und erst in einem späteren Schritt dieses Verhalten entsprechenden Einheiten zuzuweisen und damit Verantwortlichkeiten festzulegen.

Anwendung 6RQGHUHLQVDW]NUlIWH ©VXEV\VWHPª )HXHUZHKU %UDQGO|VFKHQ

9HUVFKWWHWH UHWWHQ

©VXEV\VWHPª 5HWWXQJVGLHQVW 9HUOHW]WH WUDQVSRUWLHUHQ

(UVWH+LOIH OHLVWHQ

©VXEV\VWHPª 3ROL]HL 9HUEUHFKHU MDJHQ

9HUNHKUVVQGHU YHUZDUQHQ

ABBILDUNG 12.13 System und Subsysteme, die die Use-Cases realisieren

Abbildung 12.13 zeigt exemplarisch eine Abgrenzung verschiedener Teilbereiche und ordnet beispielsweise Use-Cases wie Brand löschen und Verschüttete retten dem Subsystem Feuerwehr zu.

12.4.3 Akteur Definition An actor specifies a role played by a user or any other system that interacts with the subject.

Ö


252  12 Use-Case-Diagramm

Notation Die gebräuchlichste Notation für einen Akteur ist das Strichmännchen, mit dem Namen des Akteurs oberhalb oder unterhalb. Allerdings erlaubt Ihnen die UML, den Namen auch rechts oder links vom Strichmännchen zu notieren. Vorgeschrieben ist nur, dass der Name in der Umgebung des Strichmännchens stehen muss. Für weitere Notationsalternativen lesen Sie unter „Alternative Darstellungsformen und Zusatzinformationen“ weiter unten. Name des Akteurs

Name des Akteurs

ABBILDUNG 12.14 Die gebräuchlichste Notation für einen Akteur – das Strichmännchen.

Beschreibung Externe Interaktionspartner

Ein Akteur interagiert mit dem System, steht aber immer außerhalb davon. Beachten Sie zudem, dass ein Akteur lediglich eine Rolle darstellt, die mit dem System interagiert. Ein Akteur muss nicht zwangsläufig eine natürliche Person sein, sondern kann auch ein Sensor, ein Zeitereignis oder ein anderes Gerät sein. Weil der Akteur für eine Rolle steht, ist es zwingend erforderlich, dass er mit einem Namen versehen wird. Die UML fasst den Begriff des Akteurs sehr weit und losgelöst von Use-Case-Diagrammen, wenngleich Akteure zumeist in diesen Diagrammen verwendet werden. Akteure in Use-Case-Diagrammen In einem Use-Case-Diagramm interagiert ein Akteur mit einem Use-Case, indem er dessen Ausführung anstößt oder an der Ausführung aktiv oder passiv beteiligt ist. Zwischen dem Use-Case und dem Akteur findet ein wechselseitiger Austausch von Signalen und Daten statt. Das „Drehbuch“ dafür liefert die Verhaltensdefinition des internen Use-Case-Ablaufs.

Assoziation 6.4.8

Ö

Die Beteiligung eines Akteurs an einem Use-Case-Ablauf wird durch eine Assoziation (Abschnitt 6.4.8) zwischen dem Akteur und dem Use-Case dargestellt. Die Assoziationen müssen binär sein, das bedeutet, dass an einer Assoziation genau zwei Partner beteiligt sind. Um den Ein- und Ausgabefluss darzustellen, dürfen die Assoziationen zudem gerichtet sein. (gerichtete) Assoziation

7HVWDPHQWHUVWHOOHQ

1RWDU

*HULFKW

(binäre) Assoziation Use-Case

Name des Akteurs

(UEODVVHU

ABBILDUNG 12.15 Assoziationen zwischen Use-Case und Akteuren


12.4 Notationselemente  253

=DKOHU



'LVNRWKHN (LQWULWW]DKOHQ





 

(VVHQXQGWULQNHQ

0XVLNK|UHQ

%HVXFKHU

ABBILDUNG 12.16 Ausführliche Assoziationen zwischen Akteur und Use-Cases

Die Beziehung lässt sich weiter mit den aus Klassendiagrammen bekannten Mitteln (Abschnitt 6.4.8) verfeinern. Sie können insbesondere Rollen, Assoziationsnamen und Multiplizitäten antragen.

Beschriung der Assoziation

Das Beispiel Diskothek zeigt verschiedene Notationen von Assoziationen zwischen Akteur und Use-Case. Die mittlere Assoziation zeigt, dass ein Akteur mehrmals den Anwendungsfall Essen und Trinken anstoßen kann, aber nicht muss. Dies hängt davon ab, wie groß der Hunger und der Durst und das Stehvermögen des Besuchers sind. Ein mehrmals aufgerufener Anwendungsfall kann entweder parallel oder zu unterschiedlichen Zeiten ausgeführt werden. Die Assoziation zwischen dem Besucher und dem Use-Case Musik hören ist eine gerichtete Assoziation, die zeigt, dass der Informationsfluss nur einseitig in Richtung Akteur verläu. Bei dem Use-Case Eintritt zahlen nimmt der Akteur die Rolle des Zahlers ein. Außerdem drückt die Assoziation zwischen dem Akteur und dem Use-Case aus, dass genau ein Zahler genau einmal den Use-Case Eintritt zahlen anstößt bzw. daran beteiligt ist. Wenn Sie das System modellieren, müssen Sie die Akteure immer außerhalb der Systemgrenzen (Rahmen) anbringen. ©VXEV\VWHPª )HXHUZHKU

©VXEV\VWHPª 5HWWXQJVGLHQVW

%UJHU

3DWLHQW ©VXEV\VWHPª 3ROL]HL

6WDDW

9HUEUHFKHU

ABBILDUNG 12.17 Akteure stehen außerhalb des Systems.

Alternative Darstellungsformen und Zusatzinformationen Ein Akteur im Sinne des UML-Metamodells ist ein spezialisierter verhaltensspezifischer Classifier, der einigen Beschränkungen unterliegt. So dürfen Sie zum Beispiel, wie bereits

Akteur = spezialisierter Classifier


254  12 Use-Case-Diagramm

erwähnt, nur binäre Assoziationen an einen Akteur antragen. Zudem muss er sich außerhalb des Systems befinden.

Ö

3.2.10

Dafür steht Ihnen aber das umfangreiche Repertoire eines verhaltensspezifischen Classifiers zur Verfügung. Sie können den Akteur mit einem Schlüsselwort (Abschnitt 3.2.10) versehen. Aus der Spezialisierungsbeziehung ergibt sich auch die Rechtecksnotation, in der das Schlüsselwort «actor» anzeigt, dass es sich nicht um einen „normalen“ Classifier, sondern um einen „spezialisierten“ Classifier handelt. DFWRU!! .XQGH

.XQGH

ABBILDUNG 12.18 Der Classifier „Kunde“ – ein Akteur

Grafische Eigenkreationen

Zudem haben Sie die Möglichkeit, statt des Strichmännchens oder des Rechtecks eigene, definierte Symbole zu verwenden. Diese sind häufig eingängiger als ein Strichmännchen. Abbildung 12.19 zeigt einige typische Vertreter. Das Schlüsselwort «actor» können Sie optional angeben.

«actor» Sensor

Person

«actor» Akustisches Signal

Computer

«actor» Zeitgesteuertes Ereignis

ABBILDUNG 12.19 Alle meine Akteure …

Beziehungen zwischen Akteuren Beziehungsgeflechte außerhalb Ihres Systems Generalisierung 6.4.6

Eine weitere Classifier-Eigenscha, die Akteure besitzen, ist die Generalisierungs- und Spezialisierungsmöglichkeit (Abschnitt 6.4.6). Hierbei wird die Kommunikationsbeziehung zwischen Akteur und Use-Case weitervererbt: Der spezialisierte Akteur ist an den gleichen Use-Case-Abläufen beteiligt wie der vererbende Akteur.

Ö

Personen einstellen

Fehler machen Mensch

Verantwortung tragen Chef

ABBILDUNG 12.20 Auch ein Chef ist ein Mensch und macht Fehler.

Erlaubte Assoziationen eines Akteurs

Akteure in weiteren UML-Diagrammen Die UML erlaubt Akteuren nicht nur Beziehungen zu Use-Cases, sondern auch zu Komponenten (darunter auch Subsystemen) und Klassen (siehe Abbildung 12.21).


12.4 Notationselemente  255

Ein Akteur darf dementsprechend auch in den Diagrammen modelliert werden, in denen diese Elemente abgebildet werden. Use-Case

Komponente

Klasse

Subsystem «subsystem» Akteur

ABBILDUNG 12.21 Erlaubte Assoziationen eines Akteurs

Nebenbei bemerkt erlaubt dieser Freiheitsgrad, das aus der Strukturierten Analyse [DPl79] bekannte Kontextdiagramm mit UML-Notationsmitteln (Use-Case-Diagramm ohne UseCases als Basis) nachzubilden. Dieses Diagramm dient vorwiegend der Abgrenzung von Systemen zu Nachbarsystemen und zeigt den Ein- und Ausgangsfluss. Bestellung

Kontextdiagramme

Geld

)DVW)RRG5HVWDXUDQW Rechnung

Bestellung

Nahrung Kunde

Rechnung Zulieferer

Geld

Waren

Richtlinien

Geld

Bestätigung

Zinsen

Amt

Bank

ABBILDUNG 12.22 Auch mit der UML kann man Kontextdiagramme modellieren.

Die Assoziationen zwischen Akteur und System in Abbildung 12.22 wurden zusätzlich mit Informationsflüssen (siehe Abschnitt 6.4.15) versehen.

Anwendung Ä+DOEDXWRPDWLVFKH³ .DIIHHPDVFKLQH .DIIHHNRFKHQ YRUEHUHLWHQ /DQJVFKOlIHU .DIIHHHQWQHKPHQ

.DIIHHNRFKHQ =HLWVFKDOWXKUDQ 6WHFNGRVH

ABBILDUNG 12.23 Morgens endlich länger schlafen

Informationsfluss 6.4.15

Ö


256  12 Use-Case-Diagramm

Abbildung 12.23 zeigt die Anwendung verschiedener Darstellungen für Akteure. Einerseits wird hier ein Strichmännchen in der Rolle des Langschläfers als Akteur verwendet. Andererseits ist die Zeit in Form einer Zeitschaltuhr auch ein Akteur.

12.4.4 «include»-Beziehung Definition An include relationship defines that a use case contains the behavior defined in another use case.

Notation Abhängigkeitsbeziehung 6.4.10

Ö

Die «include»-Beziehung wird durch eine unterbrochene gerichtete Kante mit dem Schlüsselwort «include» dargestellt. Nähere Informationen zur Abhängigkeitsbeziehung finden Sie im Abschnitt 6.4.10 „Abhängigkeitsbeziehung“. «include»

ABBILDUNG 12.24 Die «include»-Beziehung

Beschreibung Verhaltensimport

Die «include»-Beziehung visualisiert, dass ein Use-Case A das Verhalten eines anderen UseCase B importiert. A

«include»

B

ABBILDUNG 12.25 Use-Case A inkludiert Use-Case B

So importiert der Use-Case Kundendaten ändern in Abbildung 12.26 den Use-Case Berechtigung prüfen. Das bedeutet, dass, während der Use-Case Kundendaten ändern instanziiert ist (abläu), in einem Ablaufschritt der Use-Case Berechtigung prüfen aufgerufen wird, dann abläu und sein Ergebnis in Kundendaten ändern genutzt wird. Kundendaten ändern

«include»

«include»

Berechtigung prüfen

Kundendaten anzeigen

ABBILDUNG 12.26 Zentral beschriebenes Verhalten inkludieren

Mehrfache Inklusion

Beispiel 12.26 zeigt auch, dass ein Use-Case durch unterschiedliche Use-Cases mehrfach inkludiert werden darf. Dadurch können Sie mehrfach benötigtes Verhalten einmalig an zentraler Stelle beschreiben und beliebig o nutzen. Formulieren Sie deshalb das ausgelagerte Verhalten so, dass es in beliebigen Use-Case-Abläufen nutzbar ist.

)OXJUHLVH )OXJUHLVH

)OXJUHLVH


12.4 Notationselemente  257

A

«include»

B

1. 3.

2.

4. 5.

6. 7.

ABBILDUNG 12.27 Der Ablauf einer «include»-Beziehung

Ein Use-Case muss jedoch nicht zwingend das Verhalten eines anderen Use-Cases impor)OXJUHLVH tieren, sondern kann auch nur von einem Ergebnis, welches der inkludierte Use-Case nach seiner Ausführung liefert, abhängig sein. Eine «include»-Beziehung ist nicht optional; der inkludierte Use-Case ist immer für den aufrufenden Use-Case notwendig, um diesen korrekt ausführen zu können. Erst durch die Inklusion ergibt sich ein (sinnvolles) Gesamtverhalten. Der Use-Case, der das Verhalten einbindet, ist somit abhängig vom Use-Case, den er inkludiert. Deswegen wird die Notation vom abhängigen, importierenden zum unabhängigen, inkludierten Use-Case gerichtet. Abbildung 12.27 zeigt das Zusammenspiel der Use-Case-Abläufe. Nachdem zum Beispiel die beiden ersten Schritte von Use-Case A abgearbeitet sind, werden die inkludierten Schritte 3 bis 5 von Use-Case B durchlaufen, bevor 6 und 7 den Gesamtablauf komplettieren. Das Verhalten von Use-Case A setzt sich somit aus den Schritten 1-7 zusammen. Das Ergebnis von Use-Case B (Schritt 5) wird in den Schritten 6 und 7 von Use-Case A genutzt. Beachten Sie, dass hier keine Parallelität vorliegt; „nach außen“ tritt ein gemeinsames Gesamtverhalten auf.

Gemeinsames Gesamtverhalten

Ein Use-Case darf sich weder selber inkludieren noch einen anderen Use-Case, der wiederum ihn selber inkludiert (Verbot zyklischer Abhängigkeiten). Dies bedeutet: Wenn UseCase A den Use-Case B inkludiert, darf Use-Case B nicht Use-Case A inkludieren.

Verbot von Zyklen

Entscheidend ist, dass durch «include»-Beziehungen bzw. die Anordnung der Use-Cases im Diagramm keine zeitlichen Reihenfolgen vorgegeben sind. Nur die Verhaltensbeschreibung des Use-Case legt fest, in welcher Reihenfolge inkludiert wird.

Keine zeitlichen Reihenfolgen

Anwendung ins Flugzeug einsteigen

)OXJUHLVH «include» Personenkontrolle durchlaufen

«include»

Passagier

ABBILDUNG 12.28 «include»-Beziehungen in der Anwendung

am Schalter einchecken

Grenzpolizist


258  12 Use-Case-Diagramm

In dem Anwendungsbeispiel einer Flugreise wird der Use-Case ins Flugzeug einsteigen hierarchisch zerlegt. Dadurch wird ausgedrückt, dass der Use-Case am Schalter einchecken komplett im Use-Case Personenkontrolle durchlaufen enthalten ist. Dieser wiederum wird vollständig im Use-Case ins Flugzeug einsteigen durchlaufen.

12.4.5 «extend»-Beziehung Definition Extend: A relationship from an extending use case to an extended use case that specifies how and when the behavior defined in the extending use case can be inserted into the behavior defined in the extended use case. Extension Point: An extension point identifies a point in the behavior of a use case where that behavior can be extended by the behavior of some other (extending) use case, as specified by an extend relationship.

Notation Eine «extend»-Beziehung ist eine unterbrochene gerichtete Kante mit der Bezeichnung «extend» vom erweiternden Use-Case zum erweiterten Use-Case. Auch diese Beziehung ist ein Spezialfall der Abhängigkeitsbeziehung. «extend»

ABBILDUNG 12.29 Die «extend»-Beziehung

Beschreibung Verhaltenserweiterung

Die «extend»-BeziehungH[WHQVLRQSRLQWV zeigt an, dass das Verhalten eines Use-Case (A) durch einen anderen Use-Case (B) erweitert werden kann, aber nicht muss. H[WHQVLRQSRLQWV

H[WHQVLRQSRLQWV G

«extend»

B

A

ABBILDUNG 12.30 Use-Case B erweitert Use-Case A

Abbildung 12.31 zeigt den Use-Case Personenkontrolle durchlaufen, der in bestimmten Fällen durch Passagier festnehmen erweitert wird. H[WHQVLRQSRLQWV Festnahme

ten d»

Passagier

«ex

Personenkontrolle durchlaufen

Passagier festnehmen

ABBILDUNG 12.31 «extend»-Beziehungen erweitern Use-Cases

Grenzpolizist


12.4 Notationselemente  259

Die Stelle im Ablauf eines Use-Cases, an dem das Verhalten erweitert werden kann, bezeichnet man als Erweiterungspunkt (engl. extension point). Ein Use-Case darf mehrere Erweiterungspunkte besitzen.

Extension point

Die Erweiterungspunkte werden in einem mit extension points bezeichneten Abschnitt innerhalb der Use-Case-Ellipse dargestellt und müssen benannt sein. Die Bezeichnung des Use-Cases verschiebt sich unter die Ellipse. Sie dürfen optional an den Namen des Erweiterungspunktes einen beliebigen Text anhängen. Dieser Text ist durch einen Doppelpunkt vom Namen des Erweiterungspunktes abzutrennen. Sie haben dadurch die Möglichkeit, den Erweiterungspunkt präziser zu beschreiben oder die Aurittsstelle im Use-Case-Ablauf anzugeben.

H[WHQVLRQSRLQWV 1DPH>)UHLWH[W@

H[WHQVLRQSRLQWV /HLEHVYLVLWDWLRQ 0HWDOOGHWHNWLRQSUIHQDXI JHIlKUOLFKH*HJHQVWlQGH *HSlFNSUIXQJSDUDOOHO]XU 3HUVRQHQSUIXQJ

8VH&DVH1DPH 3HUVRQHQNRQWUROOHGXUFKODXIHQ

ABBILDUNG 12.32 Ein Use-Case mit Erweiterungspunkten

Bei einer großen Zahl von Erweiterungspunkten empfiehlt sich, die Use-Cases in der Rechtecksnotation darzustellen (Abbildung 12.33).

8VH&DVH1DPH H[WHQVLRQSRLQWV 1DPH>)UHLWH[W@

Alternative Darstellung

3HUVRQHQNRQWUROOHGXUFKODXIHQ H[WHQVLRQSRLQWV /HLEHVYLVLWDWLRQ 0HWDOOGHWHNWLRQSUIHQDXIJHIlKUOLFKH*HJHQVWlQGH *HSlFNSUIXQJSDUDOOHO]XU3HUVRQHQSUIXQJ

ABBILDUNG 12.33 Erweiterungspunkte eines Use-Cases in der Rechtecksnotation 8VH&DVH1DPH

3HUVRQHQNRQWUROOHGXUFKODXIHQ

H[WHQVLRQSRLQWV Neben dem Erweiterungspunkt können Sie zudem eine Bedingung für die Erweiterung H[WHQVLRQSRLQWV /HLEHVYLVLWDWLRQ angeben. Die Bedingung wird bei Erreichen des0HWDOOGHWHNWLRQSUIHQDXIJHIlKUOLFKH*HJHQVWlQGH Erweiterungspunktes geprü. Ist die Bedin1DPH>)UHLWH[W@ *HSlFNSUIXQJSDUDOOHO]XU3HUVRQHQSUIXQJ

gung wahr, wird der Ablauf erweitert, das heißt, der entsprechende referenzierte Use-Case durchlaufen. Ist die Bedingung nicht erfüllt, läu der Use-Case-Ablauf „normal“ weiter. H[WHQVLRQSRLQWV ©H[WHQGª

3HUVRQIHVWQHKPHQ

/HLEHVYLVLWDWLRQ Die entsprechenden Bedingungen und der zugehörige Erweiterungspunkt werden als Notiz0HWDOOGHWHNWLRQSUIHQDXI zettel (condition)JHIlKUOLFKH*HJHQVWlQGH an die «extend»-Beziehung notiert. *HSlFNSUIXQJSDUDOOHO]XU 3HUVRQHQSUIXQJ 3HUVRQHQNRQWUROOHGXUFKODXIHQ H[WHQVLRQSRLQWV /HLEHVYLVLWDWLRQ 0HWDOOGHWHNWLRQSUIHQDXI JHIlKUOLFKH*HJHQVWlQGH *HSlFNSUIXQJSDUDOOHO]XU 3HUVRQHQSUIXQJ 3HUVRQHQNRQWUROOHGXUFKODXIHQ

&RQGLWLRQ ^.RIIHUHQWKlOW6SUHQJVWRII` H[WHQVLRQSRLQW*HSlFNSUIXQJ ©H[WHQGª

3HUVRQIHVWQHKPHQ

&RQGLWLRQ ^.RIIHUHQWKlOW6SUHQJVWRII` H[WHQVLRQSRLQW*HSlFNSUIXQJ

ABBILDUNG 12.34 Die Bedingungen eines Erweiterungspunkts als Notiz

Bedingungen der Erweiterung notieren


260  12 Use-Case-Diagramm

Die Angabe der Bedingung ist optional. Fehlt die Bedingung, wird der Use-Case immer erweitert. Ein erweiternder Use-Case kann mehrere Use-Cases erweitern und auch selbst erweitert sein.

Eine in der Praxis eher seltene Anwendung

Bisher haben wir die «extend»-Beziehung nur unter dem Aspekt betrachtet, dass ein UseCase an einem Punkt im Ablauf durch das komplette Verhalten eines weiteren Use-Case erweitert wird. Dies ist auch der in der Praxis am meisten anzutreffende Fall. Eine für die Praxis eher ungeeignete Variante ist die Möglichkeit, dass ein Use-Case stückchenweise durch das Verhalten eines anderen erweitert wird. Zum Beispiel wird Use-Case A nach dem Schritt 2 durch Use-Case B mit den Schritten 1–4 erweitert und dann nach dem Schritt 4 durch Use-Case C mit den Schritten 1-3 erweitert. Bei dieser Aueilung der Erweiterung haben wir mehrere Erweiterungspunkte für nur einen erweiternden Use-Case. In diesem Fall definiert der erste Erweiterungspunkt den ersten Teil der Erweiterung, der zweite Erweiterungspunkt den zweiten Teil der Erweiterung und so weiter. Daher ist bei der Darstellung auf die richtige Reihenfolge der Erweiterungspunkte zu achten. Die Bedingung, welche mit der «extend»-Beziehung verknüp ist, wird allerdings nur beim ersten Erweiterungspunkt geprü. Hier fällt somit automatisch die Entscheidung für alle weiteren Erweiterungspunkte dieser einen «extend»-Beziehung. In der Praxis werden Generalisierungs- und «extend»-Beziehungen leider häufig falsch eingesetzt, deshalb hier eine kurze Übersicht: Die «extend»-Beziehung dient nur der Verhaltenserweiterung, die Bedingungen unterliegt (das heißt, das Verhalten eines Use-Cases kann, muss aber nicht erweitert werden). Die Generalisierungsbeziehung hingegen kopiert und überschreibt das Verhalten des Basis-Use-Case. Die Generalisierung ist nicht die Obermenge der «extend»-Beziehung, obwohl beide das Verhalten des Basis-Use-Case durch Spezialisierung erweitern. Die Beziehungstypen unterscheiden sich darin, dass nur die Generalisierung zusätzlich das Überschreiben des Verhaltens ermöglicht und dass nur bei der «extend»Beziehung die Erweiterung durch Bedingungen steuerbar ist. Bei der Generalisierung dagegen wird immer erweitert; die Erweiterung erfolgt zur Spezifikationszeit und nicht zur Ablaufzeit. Die Generalisierung ist nur in wenigen Fällen geeignet, da sie häufig zu semantischen Zweideutigkeiten führt. Denkbar wäre eine Generalisierung, wenn mehrere alternative Handlungen in verschiedenen Schritten gleich sind, also mehrere «extend»-Beziehungen vonnöten wären.


12.4 Notationselemente  261

B

«extend»

«extend»

H[WHQVLRQSRLQWV EP1 EP2 A

Condition: {x} extension point: EP1

C

Condition: {y} extension point: EP2

1. 2.

1.

EP1 {x erfüllt}

2.

[ja]

3.

[nein]

3.

4.

4. 1.

EP2 {y erfüllt}

[ja]

2.

[nein]

3.

ABBILDUNG 12.35  Der Ablauf einer «extend»-Beziehung

Anwendung Im folgenden Beispiel wird die Verwendung der «extend»-Beziehung nochmals verdeutlicht. Dargestellt ist die mehrfache Erweiterung des Use-Cases Nahrung verspeisen und die Erweiterung des erweiternden Use-Cases Mängel reklamieren durch den Use-Case Zahlung verweigern.

©9RUEHGLQJXQJª ^+XQJHU` ([WHQVLRQ3RLQW1DFKVFKODJ

1DFKVFKODJ EHVWHOOHQ

%LHU]HOW

©H[WHQGª ©9RUEHGLQJXQJª ^0lQJHOYRUKDQGHQ` ([WHQVLRQ3RLQW5HNODPLHUHQ

H[WHQVLRQSRLQWV 1DFKVFKODJ 5HNODPLHUHQ 1DKUXQJYHUVSHLVHQ

©H[WHQGª %HVXFKHU

=DKOXQJYHUZHLJHUQ

©H[WHQGª ([WHQVLRQSRLQWV =DKOXQJ

©9RUEHGLQJXQJª ^0lQJHOQLFKWEHKREHQ` ([WHQVLRQ3RLQW=DKOXQJ

ABBILDUNG 12.36 Die «extend»-Beziehung im Einsatz

0lQJHO UHNODPLHUHQ


262  12 Use-Case-Diagramm

Tabelle 12.2 stellt nochmals die «include»- und «extend»-Beziehung einander gegenüber. TABELLE 12.2 Vergleich «include»- und «extend»-Beziehung

«include»-Beziehung Notation

A

«include»

«extend»-Beziehung «extend»

B H[WHQVLRQSRLQWV EP1 …

B

A

Bedeutung

Ablauf von A schließt immer H[WHQVLRQSRLQWV Ablauf von B ein.

Ablauf von A kann, muss aber nicht durch Ablauf von B erweitert werden.

Wann wird die Beziehung genutzt?

Ablauf von B kann in verschiedenen Use-Cases genutzt werden.

A besitzt neben Normalverhalten auslagerbare Sonderfälle.

Bedeutung für die Modellierung

A ist meist unvollständig und wird erst durch Inklusion B zu einem vollständigen Ablauf.

A ist meist vollständig und kann durch B optional erweitert werden.

Abhängigkeiten

A muss B bei der Modellierung berücksichtigen.

A muss durch Angabe von Erweiterungspunkten auf die Erweiterung durch B vorbereitet werden.

B wird unabhängig von A modelliert, um die Nutzung durch weitere Use-Cases sicherzustellen (Wiederverwendbarkeit), B muss in sich nicht vollständig sein („B weiß nicht, durch wen er inkludiert wird“).

B wird in sich vollständig und unabhängig von A modelliert („B weiß nicht, wen er erweitert“).


Register

A Abhängigkeitsbeziehung 159, 544 – extend 258 – include 256 – zur Einsatzspezifikation 236 abstraction 162 Abstraction → Abstraktionsbeziehung 162 Abstraktionsbeziehung  162 access 177 Action → Aktion 274 Activity → Aktivität 278 Activity Edge → Kanten 287 Activity Final Node → Endknoten 293 Activity Partition → Aktivitätsbereich 308 actor 254 Actor → Akteur 251 Aggregation 153 Akteur 251 – alternative Notationen 254 – erlaubte Assoziationen 254 – Generalisierung von 254 Aktion 274, 425 – Abarbeitung 266 – Objektfluss zwischen 283 – parametrisiert 275 – Vor- und Nachbedingungen 276 Aktionssequenz 426 Aktivität 278 – parametrisiert 275, 280 – Schachtelung 279 Aktivitätsbereich 290, 308 Aktivitätsdiagramm 263, 407, 502 – in der Analyse 50 – Anwendung im Projekt 271 – Elemente 264

– im Feindesign 103 – Präzisierung von Use-Cases 272 – in der Sowareanalyse 92 – in der SysML 541 Aktivitätsdiagramm → Activity Diagram 263 alt 444 Analyse 39 – Aufgaben 44 – Detaillierungstiefe 72 Anforderungsdiagramm 57, 543 apply 525 Architekturdiagramm → Kompositionsstrukturdiagramm 193 Artefakt 223, 232, 235 artifact 221, 223 Artifact → Artefakt 223 assert 459 Association → Assoziation 142 Association Class → Assoziationsklasse 157 Assoziation 142 – abgeleitete 147 – zu Akteuren 252 – Einschränkung 143 – Instanziierung 144 – als Kommunikationspfad 234 – Leserichtung 144 – Link als Instanz 192 – Multiplizität 145 – Name 144 – n-äre 155 – Navigationsrichtung 143, 150 – Navigierbarkeit 145 – qualifizierte 154 – Rollenname 145 – zirkuläre 149 Assoziationsklasse 157 Attribut 118 – abgeleitet 119


552   Register

– Datentyp 120 – Deklaration 119 – Eigenschaswert 120 – Klassen- 121 – Multiplizität 120 – Name 120 – im Sequenzdiagramm 420 – Sichtbarkeit 119 – eines Signals 434 – Vorgabewert 120 Aurittsspezifikation → Ereignis 404 Aufzählungstyp 29 Ausdruck 23 Ausführungssequenz 425, 462 Ausführungsumgebung 233, 237 Ausschnittsbildung 40 Austrittspunkt 369, 372

B bag 148 Bean siehe auch JavaBean Begriffsmodell 55, 92 – Inhalte 74 benennbares Element 422 bind 132 Black-Box 45, 85, 95 Black-Box-Anforderungen 59 Black-Box-Sicht – auf das System 245, 415 Block 537 Block Definition Diagram → Blockdefinitionsdiagramm 537 Blockdefinitionsdiagramm 537 break 448

C central-buffer 286 Choice → Entscheidung 353 Class Diagram → Klassendiagramm 107 Class → Klasse 115 Collaboration → Kollaboration 212 Collaboration Use → Kollaborationsanwendung 214 Combined Fragment → Kombiniertes Fragment 442 Comment → Kommentar 22

Communication Diagram → Kommunikationsdiagramm 473 Communication Path → Kommunikationspfad 233 Compartments 537 complete 141 Compliance Level 32 component 221 Component → Komponente 220 Component Diagram → Komponentendiagramm 215 Composite State → zusammengesetzter Zustand 357 Composite Structure Diagram → Kompositionsstrukturdiagramm 193 Condition Timeline → Zeitverlaufslinie 493 Conditional Node → Entscheidungsknoten 322 Connectable Element 209, 422 Connection Point Reference 369 Connector → Konnektor 209 consider 459 constraint 540 Constraint – Randbedingung 24 controlOperator → Kontrolloperator 541 copy 544 critical 457

D datastore 286 Data Type → Datentyp 26 Datentransferobjekt – Modellierung in der Analyse 72 Datentyp 26 Decision Node → Parallelisierungsknoten 299 Deep History → Historie 374 Default Entry 359, 366, 372 Defer 337, 359 Dekorierer 519 Dependency → Abhängigkeitsbeziehung 159 deploy 235 Deployment → Verteilungsbeziehung 235


Register  553

Deployment Diagram → Verteilungsdiagramm 227 Deployment Specification → Einsatzspezifikation 236 derive 162 deriveReqt 544 Design Pattern 205 Detaillierungstiefe – in der Analyse 72 – in der Sowareanalyse 92 – in der Systemarchitektur 87 device → Gerät 231 Diagramm 15 – Austausch 19 – Notation 16 – Verbindungen 74 Diagrammrahmen 536 Diagrammtyp 15 disjoint 141 document 224 duration 438

E Einsatzspezifikation 236 Eintrittspunkt 369, 372 Element-Import 176 else 352, 444 Endknoten 293 Endzustand 348, 367 Entity-Relationship-Modell 109 Entry Point → Eintrittspunkt 369 Entscheidung 353 – Unterschied zur Kreuzung 354 Entscheidungsknoten 322 Enumeration → Aufzählungstyp 29 Ereignis 276, 342, 404 – Zeitereignis 277 Ereignisempfänger 277 Erweiterungsbeziehung 522 Erweiterungspunkt 259 Erzeugungsnachricht 435 Event → Ereignis 404 Exception Handler 306, 448 Exception-Objekte 285 executable 224 execution environment → Ausführungsumgebung 231 Execution Specification → Ausführungssequenz 425

Exit Point → Austrittspunkt 369 Expansion Region → Mengenverarbeitungsbereich 312 Explicit Entry 360, 367, 372 Expression → Ausdruck 23 extend 258 Extend-Beziehung 47 – Bedingung 259 extended 378 Extension → Erweiterungsbeziehung 523 Extension-Point → Erweiterungspunkt 259 external 309

F Feindesign – Aufgaben 99 file 224 final 378 Final State → Endzustand 348 flow 166, 167 Flow Final Node → Endknoten 293 flow specification 539 Flusskontrolle 402 Fork → Gabelung 363 Fork Node → Parallelisierungsknoten 300 Found Message → Nachricht, gefundene 434 Frequenz 542

G Gabelung 363 Gate → Verknüpfungspunkt 465 General Ordering → Ordnungsbeziehung 461 General Value Lifeline → Wertverlaufslinie 497 Generalisierung 135 – in Paketen 179 – Mehrfachgeneralisierung 138 Generalisierungsmenge 140 generalization → Generalisierung 135 Generalization Set → Generalisierungsmenge 140


554   Register

Gerät 232 Geschäsprozess – mit Aktivitätsdiagramm 271 Guard 340, 344 Guillemets 519

H Historie 374 – flache 374 – tiefe 376 History → Historie 374

I Icon 519 ignore 458 Implementierungsbeziehung 129, 130 import 177 include 256 Include-Beziehung 47, 256 incomplete 141 Information Flow – Informationsfluss 166 Information Item → Informationseinheit 167 Informationseinheit 167 Informationsfluss 166, 255 Initial Node → Startknoten 292 Initital Pseudostate → Startzustand 346 Instanz → Instanzbeschreibung 188 Instanzbeschreibung 188 Interaction → Interaktion 419 Interaction Overview Diagram → Interaktionsübersichtsdiagramm 501 Interaction Use → Interaktionsreferenz 462 Interaktion 402, 419, 466 – im Interaktionsübersichtsdiagramm 502, 505 – im Kommunikationsdiagramm 478 – im Sequenzdiagramm 408, 419 – im Timing-Diagramm 486, 490 – Modellierung in der Analyse 65 Interaktionsbedingung 444 Interaktionsdiagramm – Interaktionsübersichtsdiagramm 501 – Kommunikationsdiagramm 473 – Sequenzdiagramm 401 – Timing-Diagramm 485

Interaktionsmodellierung 403 – Grundkonzepte 402 Interaktionsoperand 443 Interaktionsoperator 443 – Abbruchfragment 448 – Alternative Fragmente 444 – Coregion 453 – Irrelevante Nachricht 458 – Kritischer Bereich 457 – Lose Ordnung 454, 456, 506 – Negation 449 – Optionales Fragment 447 – Parallele Fragmente 452, 457 – Relevante Nachricht 459 – Schleife 450 – Sicherstellung 459 – Strenge Ordnung 456 Interaktionsrahmen → Interaktion 419 Interaktionsreferenz 462, 506 Interaktionsübersichtsdiagramm 415, 501 – Anwendung im Projekt 505 Interface → Schnittstelle 129 Internal Block Diagram → Internes Block Diagramm 538 Internes Block Diagramm 538 Interruptible Activity Region → Unterbrechungsbereich 304 iterative 315

J Join → Vereinigung 363 Join Node → Synchronisationsknoten 300 Junction → Kreuzung 351

K Kanten 287 – Bedingungen 288 – gewichtete 289 Kapselung – von Aktionen 242 – durch Komponenten 221 – im Kompositionsstrukturdiagramm 194 – durch Ports 202 Keywords → Schlüsselwörter 31 Klasse 115, 334 – abstrakte 115 – aktive 116


Register  555

Klassendiagramm 107, 196 – in der Analyse 55 – Anwendung im Projekt 113 – als Begriffsmodell 92 – im Feindesign 99 – Grundgedanke 109 – Klassen und Attribute 110 – Klassen und Objekte 110 Knoten 231 – Ausführungsumgebung 233 – Gerät 232 – Instanz 232 Kollaboration 195, 212, 465, 470 Kollaborationsanwendung 214 – Verwendung eines Musters 205, 214 Kollaborationsdiagramm → Kommunikationsdiagramm 473 Kombiniertes Fragment 442, 503 Kommentar 22 – in Diagrammen 56 Kommunikationsdiagramm 473 – Anwendung im Projekt 476 Kommunikationspartner 402, 422, 478 Kommunikationspfad 233 Kommunkationspartner – im Timing-Diagramm 486 Komponente 220 – Black-Box-Sicht 221 – eingebettete 222 – Substitution 222 – in der SysML 537 – White-Box-Sicht 221 Komponentendiagramm 215 – Anwendung im Projekt 218 – in der Sowarearchitektur 93 – in der Systemanalyse 45 – in der Systemarchitektur 79 Komposition 153, 196 Kompositionsstrukturdiagramm 193 – Anwendung im Projekt 203 Konnektor 199, 209 – Delegationskonnektor 222 – Kompositionskonnektor 222 – Multiplizitäten 210 Kontextabgrenzung 230, 255, 415 Kontextdiagramm 255 Kontrollelement 291, 503 – Endknoten 293 – Interaktionsübersichtsdiagramm 507 – Parallelisierungsknoten 299 – Startknoten 292 – Synchronisationsknoten 299 – Verbindungsknoten 295

– Verzweigungsknoten 295 Kontrollfluss 288 Kontrolloperator 541 Kreuzung 351 – Unterschied zur Entscheidung 354

L Language Units 32 Layer → Schicht 93 Lebenslinie 402, 422 – Destruktion 427 – Erzeugung 435 – im Kommunikationsdiagramm 478 – im Sequenzdiagramm 422 – im Timing-Diagramm 491 – Zerlegung 468 library 224 Lifeline → Lebenslinie 422 Link 144, 159, 188, 191 Literal 30 Literal Specification → Literal 30 loop 450 Loop Node → Schleifenknoten 317 Lose Ordnung 462 Lost Message → Nachricht, verlorene 434

M manifest 225 Mengenverarbeitungsbereich 312 – Regeln 315 merge 179 Merge Node → Verbindungsknoten 297 Message → Nachricht 428 Message Label → Sprungmarke 496 Message Sequence Charts 412 Metaklasse – Erweiterung 520, 522 Metamodell – Attribute 521 Methode 124 Model → Modell 21 Modell 21 Multiplizität – von Assoziationen 145


556   Register

– – – –

eines Attributs 120 von Konnektoren 210 von Parametern 126 von Parts 199, 208

N Nachbarsystem 255, 415 Nachricht 402, 403, 428, 480 – Antwortnachricht 432 – asynchrone 429 – bedingte 483 – Erzeugungsnachricht 435 – gefundene 434 – generische 433 – geschachtelte 481 – iterative 483 – im Kommunikationsdiagramm 480 – nebenläufige 482 – Parameter 431 – im Sequenzdiagramm 428 – sequenzielle 481 – synchrone 429 – im Timing-Diagramm 496 – verlorene 434 – im Verteilungsdiagramm 234 Nachvollziehbarkeit 58, 545 → Verfolgbarkeit 41 Namensraum – einer Klasse 118 – eines Pakets 175 neg 449 nobuffer 542 Node → Knoten 231 Notationselemente – auswählen 41 now 437

O Object Diagram → Objektdiagramm 183 Object Node → Objektknoten 280 Object → Objekt 188 Objekt 281 Objekt → Instanzbeschreibung 188 Objektdiagramm 183 – Anwendung im Projekt 187 Objektfluss 268, 288 – in einer Mengenverarbeitung 316 – Streaming 284, 303

– zwischen Aktionen 283 Objektknoten 280 – in Entscheidungsknoten 324 – als Mengenknoten 316 – Pin-Notation 283 – als Puffer und Datenspeicher 285 – in Schleifenknoten 319, 321 – in der SysML 542 – Zustände 282 Occurrence Specification → Ereignis 404 Operation 123, 430 – Deklaration 124 – Detaillierung 273 – Klassen- 126 – Name 125 – Parameter 126 – Rückgabetyp 126 – im Sequenzdiagramm 425 opt 447 optional 541 Optionale Parameter 541 ordered 148 Ordnungsbeziehung 461 – im Timing-Diagramm 498 overlapping 141 overwrite 542

P package – Attribut 119 – Operation 125 Package → Paket 175 Package Diagram → Paketdiagramm 171 Package Import → Paket-Import 176 Package Merge → Paket-Merge 179 Paket 175, 223, 516, 524 – Sichtbarkeit 177 Paketdiagramm 171 – Anwendung im Projekt 173 – in der SysML 536 Paket-Import 176, 526 Paket-Merge 179 par 452, 457 parallel 315 Parallelisierungsknoten 300 – Abarbeitung 267 Parameter – einer Interaktionsreferenz 464


Register  557

– einer Nachricht  431 Parameterbindung 133 Parameterdiagramm 540 Parametersatz 302 Parameter Set → Parametersatz 302 Parametrisierte Klasse 132 Part 197, 208, 422, 468 – Multiplizität 208 – in der SysML 538 Part Decomposition → Lebenslinie, Zerlegung 468 Pin-Notation 283 Port 211, 335, 422 – Kapselung durch 202 – in der SysML 538 – in der Systemarchitektur 83 Presentation Options 34 Primitiver Typ 28 Primitive Type → Primitiver Typ 28 private – Attribut 119 – Operation 125 – Paket 176 probability → Wahrscheinlichkeit 542 Profil 513, 524, 534 – Anwendungsbeispiel 517, 529 – für COM Component Profile 224 – für Enterprise Java Beans 224 – Erstellung von 530 – Standardprofil 529 – für Test (Testing Profile) 517 – Tools für 530 – Vor-/Nachteile 529 Profilanwendung 525 Profildiagramm 517 Profile → Profil 524 Profile Application → Profilanwendung 525 Profile Diagram → Profildiagramm 517 Property → Attribut 118 protected – Attribut 119 – Operation 125 Protocol State Machine → Protokollzustandsautomat 381 Protokolltransition 381 Protokollzustandsautomat 211, 381

provided interface 221 provides-parameter-Beziehung 47 Pseudostate → Pseudozustand 349 Pseudozustand 349 – Ein- und Austrittspunkt 369 – Entscheidung 353 – Gabelung und Vereinigung 363 – Historie 374 – Kreuzung 351 – Startzustand 346 – Terminator 356 public – Attribut 119 – Operation 125 – Paket 176

R Randbedingung 24 rate → Frequenz 542 Realisierungsbeziehung 164, 225 realization 221 Realization → Realisierungsbeziehung 164 redefined 148 refine 57, 162, 544 Region 365, 370, 440 – in Spezialisierungen 379 representation 168 required 523 required interface 221 requirement → Anforderung 543 Requirement Diagram → Anforderungsdiagramm 543

S satisfy 545 Schicht 93 Schleifenknoten 317 Schlüsselwörter 31 Schnittstelle 129, 189, 211, 221 – Modellierung in der Analyse 60 – Präzisierung von 417 – in der Systemarchitektur 83 Semantic Variation Point 34 seq 454, 457 sequence 148 Sequence Diagram → Sequenzdiagramm 401 Sequenzdiagramm 401 – Anwendung im Projekt 414


558   Register

– im Feindesign 100 – Präzisierung von Use-Cases 416 – in der SysML 536 – in der Systemarchitektur 81 Service – Modellierung in der Analyse 69 Serviceoperationen – Modellierung in der Analyse 70 Sicht – Dekompositionssicht 93 – funktionale 89, 98 – Hardware 89 – Kompositionssicht 97 – logische 87 – Soware-Sicht 89 – Überblickssicht 88, 98 Sichtbarkeit – einer Operation 125 Sichten auf Notationselemente 17 Signal 212, 276, 430, 433 Signal Empfänger 340 Signalsender 276 Signal Sender 341 Slot → Werteangaben 190 SOA 68 Sowareanalyse – Aufgaben 89 Sowarearchitektur – Aufgaben 93 source 224 Spezialisierung 378 Sprungmarke 290 – im Aktivitätsdiagramm 290 Startknoten 292 Startzustand 346, 360, 366 State → Zustand 337 State Invariant → Zustandsinvariante 439 State Machine → Zustandsautomat 329 State Machine Extension → Spezialisierung eines Zustands 378 State Timeline → Zeitverlaufslinie 493 static 121 – Operation 128 Stereotyp 516, 518 – anwenden 40 – Standardstereotyp 520 – in der Systemarchitektur 80 stream 284

streaming 315 strict 456, 457 structured 311 Structured Activity Node → Strukturierter Knoten 311 Strukturdiagramm 105 – Klassendiagramm 107 – Komponentendiagramm 215 – Kompositionsstrukturdiagramm 193 – Objektdiagramm 183 – Paketdiagramm 171 – Profildiagramm 517 – Verteilungsdiagramm 227 Strukturierter Knoten 311 Subject → System 249 Submachine State → Unterzustandsautomatenzustand 371 subsets 149 substitute 165 Substitution – von Aktionen 306 – bei Generalisierung 138 Substitutionsbeziehung 165 subsystem 221 Subsystem 250 Swallow History → Historie 374 Swimlanes → Aktivitätsbereich 308 Synchronisationsknoten 299, 300 – Abarbeitung 267 SysML 57, 533 System 249 Systemanalyse → Analyse 39 Systemarchitektur – Aufgaben 78 – Beschreiben der Schnittstellen 82 – Verteilen der Verantwortlichkeiten 81 – Zerlegung 79 Systemgrenze 45 Systemkontext 230, 415 Szenario – als Instanz einer Interaktion 188

T Tabellennotation 18 Tagged Value 522 Tailoring 513 – leichtgewichtig 514 – schwergewichtig 514


Register  559

Templateable Element → Parametrisierte Klasse 132 Terminate Pseudostate – Terminator 356 Terminator 356 Testfall 543 Timing-Diagramm 485 – Anwendung im Projekt 489 Token 265 – Daten-Token 281 – Konzept 265 – Lebenszyklus 269 – Verweildauer 268 trace 163, 545 Trace 404 Traceability → Nachvollziehbarkeit 545 → Verfolgbarkeit 41 Transition 340 – Abarbeitung 345 – interne 337, 357 – in Protokollzustandsautomaten 382 – Selbsttransition 341 – in Spezialisierungen 378 Trigger 342 – CallTrigger 342, 383 – ChangeTrigger 342 – SignalTrigger 342 – TimeTrigger 342 – bei Transitionen 340 – in Zuständen 337, 359

U UML 2 – Grundkonzepte 13 – Historie 5 union 149 Unterbrechungsbereich 304 Unterbrechungskante 304 Unterzustandsautomatenzustand 371 Usage → Verwendungsbeziehung 161 use 161, 225 Use-Case 246 – Ablauf 242 – Ausführung 247 – Detaillierung 272 – Generalisierung 247 – Identifikation 47 – mehrfache Instanziierung 247 – Modellierung der Auslöser 63 – Präzisierung 245, 333, 416 – realisierende Classifier 250

– Realisierung 204 – Ursprung 243 – Verfeinerung 48 Use-Case-Analyse 47, 242 Use-Case-Beschreibung 49 Use-Case-Diagramm 241 – in der Analyse 47 – Anwendung im Projekt 245 – in der Sowareanalyse 91 – in der SysML 536 – als Verfeinerung 53

V Verbindungsknoten 295, 297 Vereinigung 363, 368 Vererbung 137 Verfolgbarkeit 41 Verfolgbarkeit → Nachvollziehbarkeit 545 Verhalten – an Transitionen 344 – bei Transitionen 340 – in Zuständen 337 Verhaltensaufruf 274 Verhaltensdiagramm 239 – Aktivitätsdiagramm 263 – Interaktionsübersichtsdiagramm 501 – Kommunikationsdiagramm 473 – Sequenzdiagramm 401 – Timing-Diagramm 485 – Use-Case-Diagramm 241 – Zustandsautomat 329 Verhaltensspezifikation 239 verify 544 Verknüpfungspunkt 465 Verteilungsbeziehung 234 Verteilungsdiagramm 227 – Anwendung im Projekt 229 Verwendungsbeziehung 161 Verzweigungsknoten 295, 296, 318, 323 Vollständigkeit 73 Vorgehensempfehlung 9 Vorgehensmodell 9

W Wahrscheinlichkeit 542 Wartbarkeit 58 Werteangaben 190 Wertverlaufslinie 497 White-Box 85, 95

X xor 146


560   Register

Z Zeitbedingung 436, 438, 506 Zeitdauer 437 Zeitdauerintervall 437 Zeitdiagramm → Timing-Diagramm 485 Zeitpunkt 436 Zeitpunktintervall 436 Zeitverlaufsdiagramm → Timing-Diagramm 485 Zeitverlaufslinie 493 – Ende 494 zusammengesetzter Zustand  357 Zustand 337 – aktiv 338 – Austrittsverhalten 337, 357, 362 – Default Entry 359 – einfacher 337 – Eintrittsverhalten 337, 357, 359 – Explicit Entry 360 – Hierarchisierung 358

– inaktiv 338 – orthogonale 366 – in Protokollzustandsautomaten 381 – in Spezialisierungen 379 – Spezialisierung von 378 – im Timing-Diagramm 492 – Unterzustand 358 – verlassen 341, 361 – versteckter 357 – zusammengesetzter 357 Zustandsautomat 329, 430, 440 – in der Analyse 54 – Anwendung im Projekt 333 – Codeabbildung  384 – im Feindesign 101 – Präzisierung von Use-Cases 333 – in der Sowareanalyse 92 – Spezialisierung von 378 – in der SysML 536 Zustandsinvariante 381, 439 Zustandsverhalten 337, 357

Leseprobe UML 2 glasklar, 4. Auflage  

Leseprobe UML 2 glasklar, 4. Auflage

Read more
Read more
Similar to
Popular now
Just for you