Anwendungsfalldiagramm: Unterschied zwischen den Versionen

Aus FLBK-Wiki
Zur Navigation springen Zur Suche springen
Keine Bearbeitungszusammenfassung
Keine Bearbeitungszusammenfassung
Zeile 1: Zeile 1:
== Einführung ==
== Einführung in die Use-Case-Modellierung ==
Die [[Unified Modeling Language]] (Vereinheitlichte Modellierungssprache), kurz '''UML''', ist eine standardisierte grafische Modellierungssprache zur Beschreibung von Anforderungen und Softwarearchitekturen. Das '''Anwendungsfalldiagramm''' ist Teil der UML und wird im englischsprachigen Raum auch als '''Use Case Diagramm''' bezeichnet.  
Die [[Unified Modeling Language]] (Vereinheitlichte Modellierungssprache), kurz '''UML''', ist eine standardisierte grafische Modellierungssprache zur Spezifikation, Konstruktion und Dokumentation von Softwareteilen und anderen Systemen. Das '''Anwendungsfalldiagramm''' (im englischsprachigen Raum '''Use Case Diagramm''') gehört zu den Verhaltensdiagrammen der UML.


Ziel des Anwendungsfalldiagramms ist es, in der Analysephase die Anforderungen des Auftraggebers aus fachlicher Sicht für alle Beteiligten verständlich, übersichtlich und vollständig zu modellieren. Es dient als zentrales Kommunikationsmittel, um zwischen potenziellen Anwendern, Auftraggebern (Fachseite) und Auftragnehmern (Entwicklerteam) zu vermitteln. Als strukturierte Anforderungsbeschreibung können Anwendungsfalldiagramme direkt in das Lastenheft mit aufgenommen werden.
=== Zielsetzung im Requirements Engineering ===
In der Analysephase (Anforderungsermittlung / Requirements Engineering) ist es das primäre Ziel des Anwendungsfalldiagramms, das geplante System aus der '''externen Beobachterperspektive''' zu beschreiben. Es modelliert das "Was" (welche Funktionen bietet das System?) und grenzt sich strikt vom "Wie" (wie werden diese Funktionen technisch umgesetzt?) ab.  


Das Anwendungsfalldiagramm besteht aus drei wesentlichen Elementen:<ref>Heide Balzer: ''Lehrbuch der Objektmodellierung - Analyse und Entwurf'', Spektrum Akademischer Verlag, S. 62 ff.</ref>
Es dient als zentrales Kommunikationsmittel zwischen:
# '''Akteure (engl. ''actors''):''' In einem Anwendungsfalldiagramm werden potenzielle Benutzer des Systems identifiziert. Diese Benutzer nennt man Akteure. Jeder Akteur hat gewisse Erwartungen an die Software. Benutzer erwarten, dass das Programm ihnen hilft, ihre Aufgaben schneller und einfacher zu lösen.
* '''Auftraggebern / potenziellen Anwendern (Fachseite):''' Diese können das Diagramm ohne Programmierkenntnisse verstehen.
# '''Anwendungsfälle (engl. ''use cases''):''' Diese Aufgaben der Benutzer nennt man Anwendungsfälle. Sie erzeugen für den Anwender ein Ergebnis von messbarem Wert.
* '''Auftragnehmern (Entwicklerteam / Systemarchitekten):''' Für diese bildet das Diagramm die Grundlage für die Systemarchitektur.
# '''Beziehungen (engl. ''relations''):''' Die Verbindung zwischen Akteur und Anwendungsfall (oder zwischen Anwendungsfällen untereinander) nennt man Beziehung oder Relation.


''Hinweis zur Abgrenzung:'' Der detaillierte, prozessuale Ablauf von Anwendungsfällen wird nicht hier, sondern vorzugsweise in einem UML-Aktivitätendiagramm dargestellt.
Daher fließen Anwendungsfalldiagramme als strukturierte Anforderungsbeschreibung in das '''Lastenheft''' (Forderungen des Auftraggebers) und später detailliert in das '''Pflichtenheft''' (Umsetzungsvorgaben des Auftragnehmers) ein.


== Gesamtbeispiel (Systemkontext) ==
=== Die drei Kernelemente ===
Ein vollständiges Anwendungsfalldiagramm führt alle Elemente innerhalb eines umschließenden '''Systemrahmens (Systemgrenze)''' zusammen. Die Akteure befinden sich außerhalb des Systems, während die Anwendungsfälle innerhalb des Systems liegen und über Beziehungen miteinander verknüpft sind.
Das Diagramm besteht aus drei essenziellen Bausteinen:<ref>Heide Balzer: ''Lehrbuch der Objektmodellierung - Analyse und Entwurf'', Spektrum Akademischer Verlag, S. 62 ff.</ref>
# '''Akteure (engl. ''actors''):''' Sie repräsentieren externe Entitäten, die mit dem System interagieren. Wichtig: Ein Akteur ist immer eine '''Rolle''' (z. B. "Kunde"), niemals eine konkrete Person (z. B. "Herr Müller"). Auch externe Fremdsysteme (wie ein Zahlungsanbieter) treten als Akteure auf.
# '''Anwendungsfälle (engl. ''use cases''):''' Sie beschreiben eine in sich abgeschlossene Aufgabe, die für den Akteur einen messbaren, fachlichen Mehrwert erzeugt.
# '''Beziehungen (engl. ''relations''):''' Die Interaktionspfade zwischen Akteur und Anwendungsfall oder die Abhängigkeiten von Anwendungsfällen untereinander.


[[Datei:AnwendungsfallSys.png|mini|Gesamtbeispiel mit Systemgrenze und Akteuren]]
''Hinweis zur Abgrenzung:'' Der detaillierte, prozessuale Ablauf (Kontrollfluss) innerhalb eines Anwendungsfalls wird im Use-Case-Diagramm bewusst abstrahiert. Hierfür werden in der UML ergänzend '''Aktivitätendiagramme''' oder '''Sequenzdiagramme''' genutzt.


== Notation ==
== Systemkontext und Systemgrenze ==
Der Aufbau eines Anwendungsfalldiagramms folgt methodisch folgenden drei Regeln:
Ein vollständiges Anwendungsfalldiagramm führt alle Elemente innerhalb eines umschließenden '''Systemrahmens (Systemgrenze / System Boundary)''' zusammen.
Die Systemgrenze ist ein fundamentales Konzept: Sie trennt das zu entwickelnde System strikt von seiner Umwelt. Akteure befinden sich als externe Rollen immer '''außerhalb''' des Systems, während die Anwendungsfälle die Funktionalität '''innerhalb''' des Systems definieren.


# '''Akteure identifizieren:''' Als erstes sollte man klären, welche unterschiedlichen Akteure die zu erstellende Software benutzen werden. Akteure werden als „Strichmännchen“ dargestellt. Alle notwendigen Benutzer der Software sind darzustellen. Dies sind in der Regel Personen wie Kunden, Mitarbeiter oder Administratoren. Es können aber auch andere Software-Systeme sein, die eine Anwendung benutzen werden. Jeder Akteur sollte einen aussagekräftigen und selbsterklärenden Namen haben. „User“ bzw. „Akteur“ sind keine aussagekräftigen Namen, da sie für jede Software gültig sind.
[[Datei:AnwendungsfallSys.png|mini|Gesamtbeispiel: Der Rahmen definiert die Systemgrenze. Akteure stehen außerhalb, Use Cases innerhalb.]]
# '''Anwendungsfälle definieren:''' Als zweites sollte geklärt werden, welche Anwendungsfälle die Software erfüllen soll. Anwendungsfälle werden in Ellipsen dargestellt. In diese Ellipsen wird die inhaltliche Beschreibung geschrieben. Es wird empfohlen, den Anwendungsfall kurz und aussagekräftig zusammenzufassen. Trotz der Kürze muss er verständlich bleiben! Daher sollte er in einem ganzen, aber möglichst knappen Satz im Sinne von ''Subjekt-Prädikat-Objekt'' (bzw. im Infinitiv) formuliert werden.
# '''Beziehungen verknüpfen:''' Erst im dritten Schritt werden die Anwendungsfälle und Akteure über Beziehungen miteinander verbunden. Beziehungen zwischen Akteuren und Anwendungsfällen müssen durch Linien gekennzeichnet werden.


== Beziehungen ==
== Notation und Erstellung ==
Die Erstellung eines Anwendungsfalldiagramms folgt methodisch diesen drei Schritten:
 
# '''Akteure identifizieren:''' Wer oder was interagiert mit der Software? Akteure werden als „Strichmännchen“ (Menschen) oder als Rechteck mit dem Stereotyp <code><<system>></code> (externe Systeme) dargestellt. Der Name muss zwingend eine präzise Rolle beschreiben (z. B. ''Sachbearbeiter'', ''Administrator''). Generische Namen wie "User" sind als Modellierungsfehler zu betrachten.
# '''Anwendungsfälle definieren:''' Welche fachlichen Ziele sollen erreicht werden? Anwendungsfälle werden als Ellipsen gezeichnet. Die Benennung erfolgt imperativ oder im Infinitiv im Format ''Subjekt-Prädikat-Objekt'' (z. B. "Rechnung stornieren", "Artikel suchen"). Die Formulierung muss prägnant und fachlich verständlich sein.
# '''Beziehungen verknüpfen:''' Akteure und Anwendungsfälle werden durch Kommunikationspfade (Linien) verbunden, um den Interaktionsfluss sichtbar zu machen.
 
== Beziehungsarten (Relationen) ==


=== Assoziation ===
=== Assoziation ===
Assoziationen verbinden Akteure mit Use Cases. Eine Assoziation bedeutet, dass der User die Aktion ausführen kann und somit mit dem System interagiert, das den Use Case enthält. Dabei darf ein einzelner Use Case mit mehreren Akteuren und ein einzelner Akteur mit mehreren Use Cases verbunden sein. Eine einzelne Assoziation muss immer genau zwei Elemente miteinander verbinden (binäre Assoziation).
Assoziationen sind die grundlegenden Kommunikationspfade zwischen Akteur und Use Case. Sie drücken aus, dass der Akteur mit dem System interagiert, um den Anwendungsfall auszuführen. Eine Assoziation ist immer binär (verbindet exakt zwei Elemente). Ein Akteur kann mit mehreren Use Cases assoziiert sein und umgekehrt.


==== Ungerichtete Assoziation ====
==== Ungerichtete Assoziation ====
Ungerichtete Assoziationen werden als eine durchgehende Linie dargestellt. Es ist die offenste Form der Darstellung und lässt Spielraum für Interpretation bezüglich des genauen Datenflusses.
Wird als durchgehende Linie ohne Pfeilspitzen dargestellt. Sie zeigt an, dass eine Kommunikation stattfindet, lässt aber die Initiierungsrichtung (wer den Anstoß gibt) offen. Dies ist die häufigste und flexibelste Form in frühen Analysephasen.


[[Datei:AnwendungsfallEinweihungsfeier.png|mini|Beispiel einer ungerichteten Assoziation]]
[[Datei:AnwendungsfallEinweihungsfeier.png|mini|Beispiel einer ungerichteten Assoziation: Die Interaktion ist bidirektional.]]


==== Gerichtete Assoziation ====
==== Gerichtete Assoziation ====
Pfeile an der Assoziation geben an, wer die Aktion initiieren kann. Hier spricht man von einer gerichteten Assoziation. Ein Pfeil, der auf den Use Case gerichtet ist, besagt, dass nur der Akteur die Aktion initiieren kann, während ein Pfeil, der auf den Akteur zeigt, besagt, dass nur der Use Case die Aktion initiieren kann. Können beide Seiten die Aktion initiieren, werden die Pfeile weggelassen, anstatt zwei Pfeile zu setzen.
Verfügt über eine offene Pfeilspitze und gibt die Navigierbarkeit bzw. den Initiator an. Ein Pfeil zum Use Case bedeutet: Der Akteur stößt den Prozess aktiv an. Ein Pfeil zum Akteur bedeutet: Das System initiiert die Kommunikation zum Akteur (z. B. automatischer E-Mail-Versand an den Kunden). Können beide den Prozess anstoßen, wird auf Pfeile komplett verzichtet.


[[Datei:AnwendungsfallHotelreservierung.png|mini|Beispiel einer gerichteten Assoziation]]
[[Datei:AnwendungsfallHotelreservierung.png|mini|Beispiel einer gerichteten Assoziation: Die Pfeilspitze definiert den Initiator.]]


=== Multiplizitäten ===
=== Multiplizitäten ===
Multiplizitäten geben an, wie viele Akteure mit wie vielen Anwendungsfällen in Beziehung stehen. Sie werden an gerichtete oder ungerichtete Assoziationen modelliert.
Multiplizitäten (auch Kardinalitäten genannt) definieren, wie viele Instanzen eines Akteurs zeitgleich an wie vielen Instanzen eines Anwendungsfalls beteiligt sind.
 
[[Datei:AnwendungsfallTischtennis.png|mini|Darstellung von Multiplizitäten beim Tischtennis-Rundlauf]]


Die Multiplizitäten sind im obigen Beispiel wie folgt zu lesen:
[[Datei:AnwendungsfallTischtennis.png|mini|Darstellung von Multiplizitäten am Beispiel eines Tischtennis-Rundlaufs]]
* An einem Tischtennis-Rundlauf sind mindestens 3 Spielerinnen beteiligt. Die Obergrenze ist als <code>*</code> bzw. beliebig definiert und die Untergrenze ist <code>3</code>. Jede Spielerin jedoch kann an exakt einem Rundlauf-Spiel teilnehmen. Hier sind die Ober- und Untergrenze <code>1</code>.
* An einem Rundlaufspiel können keine oder beliebig viele Schiedsrichterinnen beteiligt sein (<code>0..*</code>). Jede Schiedsrichterin kann an höchstens einem Rundlaufspiel beteiligt sein (<code>0..1</code>).


Da diese Information jedoch häufig für die Adressaten des Use Case Diagramms keine Rolle spielt, werden Multiplizitäten im Anwendungsfalldiagramm eher selten notiert. Eine elementare Rolle spielen sie hingegen beim [[Klassendiagramm]].
'''Lesebeispiel der Abbildung:'''
* An einem Tischtennis-Rundlauf (Use Case) nehmen zwingend mindestens 3 bis beliebig viele (<code>*</code>) Spielerinnen teil (Notation: <code>3..*</code>). Jede einzelne Spielerin nimmt jedoch zu einem gegebenen Zeitpunkt an exakt 1 Rundlauf-Spiel teil (Notation: <code>1</code>).
* Ein Spiel kann völlig ohne oder mit beliebig vielen Schiedsrichterinnen stattfinden (<code>0..*</code>). Eine Schiedsrichterin überwacht gleichzeitig maximal ein Spiel (<code>0..1</code>).


=== Includes ===
''Prüfungshinweis:'' Multiplizitäten spielen in Use-Case-Diagrammen in der Praxis eine untergeordnete Rolle, da sie das Diagramm schnell überladen. Ihre volle konzeptionelle Bedeutung entfalten sie erst im strukturellen [[Klassendiagramm]].
<code>include</code>-Beziehungen (dt. beinhalten) werden mittels einer mit <code><<include>></code> gekennzeichneten gestrichelten Linie und einem Pfeil zum inkludierten Anwendungsfall gekennzeichnet. Hierdurch wird abgebildet, dass der inkludierte Anwendungsfall immer zwingend ausgeführt werden muss.


Die Include-Anweisung gibt an, dass ein Use Case alle inkludierten Use Cases zwingend mitbenutzt. Die Include-Beziehung wird durch eine gestrichelte Linie dargestellt, die durch das Schlüsselwort <code><<include>></code> gekennzeichnet ist und vom Basis Use Case einen Pfeil in Richtung des zu inkludierenden Use Cases hat.
=== Abhängigkeiten zwischen Anwendungsfällen ===


[[Datei:AnwendungsfallHotelreservierungKomplex.png|mini|Include-Beziehung zwischen Anwendungsfällen]]
==== Include-Beziehung (<<include>>) ====
Die <code>include</code>-Beziehung dient der '''Vermeidung von Redundanz'''. Sie lagert gemeinsames Verhalten in einen eigenen Use Case aus. Der gestrichelte Pfeil zeigt vom Basis-Use-Case zum inkludierten Use Case.
* '''Semantik:''' Wenn der Basis-Anwendungsfall ausgeführt wird, wird der inkludierte Anwendungsfall '''zwingend immer (zu 100%)''' mit ausgeführt. Der Basis-Use-Case ist ohne das Inkludat unvollständig.


=== Extend ===
[[Datei:AnwendungsfallHotelreservierungKomplex.png|mini|Include-Beziehung: Der inkludierte Prozess wird zwingend aufgerufen.]]
Die <code>extend</code>-Beziehung gibt an, dass ein Use Case optional ist und nur unter bestimmten Bedingungen ausgeführt wird. Sie wird durch eine gestrichelte Linie dargestellt, die durch das Schlüsselwort <code><<extend>></code> gekennzeichnet ist und vom Extension Use Case (Erweiterung) einen Pfeil in Richtung des Basis Use Cases hat.


Der Basis Use Case bestimmt sogenannte Erweiterungspunkte (''Extension Points''), die den präzisen Ort innerhalb des Use Cases angeben, an dem Extensions hinzugefügt werden dürfen. Erweiterungspunkte werden dargestellt, indem dem Use Case eine horizontale Linie hinzugefügt wird, unter der das Schlüsselwort <code>extension points</code> steht, gefolgt von den Namen der Erweiterungspunkte.
==== Extend-Beziehung (<<extend>>) ====
Die <code>extend</code>-Beziehung modelliert '''Ausnahmebehandlungen oder optionale Erweiterungen'''. Der gestrichelte Pfeil zeigt (im Gegensatz zum Include!) vom erweiternden Use Case (Extension) zurück auf den Basis-Use-Case.
* '''Semantik:''' Die Erweiterung wird nur unter bestimmten Bedingungen ausgeführt. Der Basis-Use-Case ist auch ohne die Erweiterung vollständig lauffähig.


Optional kann an eine Extend-Anweisung eine Bedingung (''Condition'') hinzugefügt werden, die beschreibt, unter welchen Voraussetzungen bezogen auf den Erweiterungspunkt der Extend Use Case ausgeführt wird. Die Bedingung wird in der UML als Notizzettel dargestellt, der das Schlüsselwort <code>Condition</code> enthält, gefolgt von der Bedingung in geschweiften Klammern und darunter der Erweiterungspunkt, auf den sich die Bedingung bezieht. Die Bedingung ist mit einer gestrichelten Linie mit der Linie der Extend-Anweisung verbunden.
Die Integration erfolgt über sogenannte '''Erweiterungspunkte (Extension Points)'''. Diese markieren im Basis-Use-Case (unterhalb eines Trennstrichs) die genaue Stelle des Eingriffs. Optional kann über ein Notizsymbol eine logische '''Bedingung (Condition)''' angefügt werden, die prüft, ob die Erweiterung überhaupt zündet.


[[Datei:AnwendungsfalldiagrammHotelreservierungKomplexErkl.png|mini|Extend-Beziehung inklusive Erweiterungspunkten und Bedingungen (Condition)]]
[[Datei:AnwendungsfalldiagrammHotelreservierungKomplexErkl.png|mini|Extend-Beziehung mit definierten Erweiterungspunkten und auslösender Bedingung (Condition).]]


=== Generalisierung ===
=== Generalisierung (Vererbung) ===
Zwischen zwei Anwendungsfällen oder Akteuren kann eine Generalisierungsbeziehung existieren (Vererbungspfeil mit hohler, geschlossener Pfeilspitze). Ausgedrückt wird damit, dass der spezialisierte Anwendungsfall oder Akteur alle Bestandteile des allgemeinen Anwendungsfalls oder Akteurs beinhaltet. Das spezialisierte Element konkretisiert oder erweitert das allgemeine Element.
Die Generalisierung entspricht dem aus der Objektorientierung bekannten Konzept der Vererbung ('''"Ist-ein"-Beziehung'''). Sie wird mit einer durchgehenden Linie und einer hohlen, geschlossenen Pfeilspitze dargestellt, die vom speziellen zum allgemeinen Element zeigt.


[[Datei:AnwendungsfallCD.png|mini|Generalisierungsbeziehung (Vererbung)]]
[[Datei:AnwendungsfallCD.png|mini|Generalisierungsbeziehung: Spezialisierung von Anwendungsfällen oder Akteuren.]]


Ein typisches Beispiel bei Akteuren: Der Akteur '''Fahrer''' ist eine Spezialisierung von '''Anwender'''. Ein Fahrer besitzt alle Fähigkeiten, Use Cases und Eigenschaften eines allgemeinen Anwenders, wie z.B. Vorname, Nachname, Benutzername und dass er sich mit dem Benutzernamen und Passwort anmelden kann (login), fügt jedoch spezifische Eigenschaften oder Rollen hinzu. Ebenso lassen sich allgemeine Anwendungsfälle (z. B. "Medium brennen") durch speziellere Anwendungsfälle (z. B. "CD brennen", "DVD brennen") generalisieren.
* '''Generalisierung von Akteuren:''' Der Akteur ''Fahrer'' ist eine Spezialisierung des Akteurs ''Anwender''. Der Fahrer erbt alle Zugriffsrechte und Use Cases des allgemeinen Anwenders (z. B. "Login"), besitzt darüber hinaus aber erweiterte, spezifische Berechtigungen (z. B. "Fahrzeug starten").
* '''Generalisierung von Use Cases:''' Ein allgemeiner Anwendungsfall wie ''„Zahlung durchführen“'' kann durch spezialisierte Anwendungsfälle wie ''„Per Kreditkarte zahlen“'' oder ''„Per PayPal zahlen“'' generalisiert werden. Die speziellen Fälle erben die grundlegende Funktionalität, setzen sie aber im Detail abweichend um.


[[Kategorie:Modellierung]]
[[Kategorie:Modellierung]]
[[Kategorie:FI_I_SDM]]
[[Kategorie:FI_I_SDM]]
[[Kategorie:AHR_I_Informatik LK]]
[[Kategorie:AHR_I_Informatik LK]]

Version vom 22. Mai 2026, 08:44 Uhr

Einführung in die Use-Case-Modellierung

Die Unified Modeling Language (Vereinheitlichte Modellierungssprache), kurz UML, ist eine standardisierte grafische Modellierungssprache zur Spezifikation, Konstruktion und Dokumentation von Softwareteilen und anderen Systemen. Das Anwendungsfalldiagramm (im englischsprachigen Raum Use Case Diagramm) gehört zu den Verhaltensdiagrammen der UML.

Zielsetzung im Requirements Engineering

In der Analysephase (Anforderungsermittlung / Requirements Engineering) ist es das primäre Ziel des Anwendungsfalldiagramms, das geplante System aus der externen Beobachterperspektive zu beschreiben. Es modelliert das "Was" (welche Funktionen bietet das System?) und grenzt sich strikt vom "Wie" (wie werden diese Funktionen technisch umgesetzt?) ab.

Es dient als zentrales Kommunikationsmittel zwischen:

  • Auftraggebern / potenziellen Anwendern (Fachseite): Diese können das Diagramm ohne Programmierkenntnisse verstehen.
  • Auftragnehmern (Entwicklerteam / Systemarchitekten): Für diese bildet das Diagramm die Grundlage für die Systemarchitektur.

Daher fließen Anwendungsfalldiagramme als strukturierte Anforderungsbeschreibung in das Lastenheft (Forderungen des Auftraggebers) und später detailliert in das Pflichtenheft (Umsetzungsvorgaben des Auftragnehmers) ein.

Die drei Kernelemente

Das Diagramm besteht aus drei essenziellen Bausteinen:<ref>Heide Balzer: Lehrbuch der Objektmodellierung - Analyse und Entwurf, Spektrum Akademischer Verlag, S. 62 ff.</ref>

  1. Akteure (engl. actors): Sie repräsentieren externe Entitäten, die mit dem System interagieren. Wichtig: Ein Akteur ist immer eine Rolle (z. B. "Kunde"), niemals eine konkrete Person (z. B. "Herr Müller"). Auch externe Fremdsysteme (wie ein Zahlungsanbieter) treten als Akteure auf.
  2. Anwendungsfälle (engl. use cases): Sie beschreiben eine in sich abgeschlossene Aufgabe, die für den Akteur einen messbaren, fachlichen Mehrwert erzeugt.
  3. Beziehungen (engl. relations): Die Interaktionspfade zwischen Akteur und Anwendungsfall oder die Abhängigkeiten von Anwendungsfällen untereinander.

Hinweis zur Abgrenzung: Der detaillierte, prozessuale Ablauf (Kontrollfluss) innerhalb eines Anwendungsfalls wird im Use-Case-Diagramm bewusst abstrahiert. Hierfür werden in der UML ergänzend Aktivitätendiagramme oder Sequenzdiagramme genutzt.

Systemkontext und Systemgrenze

Ein vollständiges Anwendungsfalldiagramm führt alle Elemente innerhalb eines umschließenden Systemrahmens (Systemgrenze / System Boundary) zusammen. Die Systemgrenze ist ein fundamentales Konzept: Sie trennt das zu entwickelnde System strikt von seiner Umwelt. Akteure befinden sich als externe Rollen immer außerhalb des Systems, während die Anwendungsfälle die Funktionalität innerhalb des Systems definieren.

Gesamtbeispiel: Der Rahmen definiert die Systemgrenze. Akteure stehen außerhalb, Use Cases innerhalb.

Notation und Erstellung

Die Erstellung eines Anwendungsfalldiagramms folgt methodisch diesen drei Schritten:

  1. Akteure identifizieren: Wer oder was interagiert mit der Software? Akteure werden als „Strichmännchen“ (Menschen) oder als Rechteck mit dem Stereotyp <<system>> (externe Systeme) dargestellt. Der Name muss zwingend eine präzise Rolle beschreiben (z. B. Sachbearbeiter, Administrator). Generische Namen wie "User" sind als Modellierungsfehler zu betrachten.
  2. Anwendungsfälle definieren: Welche fachlichen Ziele sollen erreicht werden? Anwendungsfälle werden als Ellipsen gezeichnet. Die Benennung erfolgt imperativ oder im Infinitiv im Format Subjekt-Prädikat-Objekt (z. B. "Rechnung stornieren", "Artikel suchen"). Die Formulierung muss prägnant und fachlich verständlich sein.
  3. Beziehungen verknüpfen: Akteure und Anwendungsfälle werden durch Kommunikationspfade (Linien) verbunden, um den Interaktionsfluss sichtbar zu machen.

Beziehungsarten (Relationen)

Assoziation

Assoziationen sind die grundlegenden Kommunikationspfade zwischen Akteur und Use Case. Sie drücken aus, dass der Akteur mit dem System interagiert, um den Anwendungsfall auszuführen. Eine Assoziation ist immer binär (verbindet exakt zwei Elemente). Ein Akteur kann mit mehreren Use Cases assoziiert sein und umgekehrt.

Ungerichtete Assoziation

Wird als durchgehende Linie ohne Pfeilspitzen dargestellt. Sie zeigt an, dass eine Kommunikation stattfindet, lässt aber die Initiierungsrichtung (wer den Anstoß gibt) offen. Dies ist die häufigste und flexibelste Form in frühen Analysephasen.

Beispiel einer ungerichteten Assoziation: Die Interaktion ist bidirektional.

Gerichtete Assoziation

Verfügt über eine offene Pfeilspitze und gibt die Navigierbarkeit bzw. den Initiator an. Ein Pfeil zum Use Case bedeutet: Der Akteur stößt den Prozess aktiv an. Ein Pfeil zum Akteur bedeutet: Das System initiiert die Kommunikation zum Akteur (z. B. automatischer E-Mail-Versand an den Kunden). Können beide den Prozess anstoßen, wird auf Pfeile komplett verzichtet.

Beispiel einer gerichteten Assoziation: Die Pfeilspitze definiert den Initiator.

Multiplizitäten

Multiplizitäten (auch Kardinalitäten genannt) definieren, wie viele Instanzen eines Akteurs zeitgleich an wie vielen Instanzen eines Anwendungsfalls beteiligt sind.

Darstellung von Multiplizitäten am Beispiel eines Tischtennis-Rundlaufs

Lesebeispiel der Abbildung:

  • An einem Tischtennis-Rundlauf (Use Case) nehmen zwingend mindestens 3 bis beliebig viele (*) Spielerinnen teil (Notation: 3..*). Jede einzelne Spielerin nimmt jedoch zu einem gegebenen Zeitpunkt an exakt 1 Rundlauf-Spiel teil (Notation: 1).
  • Ein Spiel kann völlig ohne oder mit beliebig vielen Schiedsrichterinnen stattfinden (0..*). Eine Schiedsrichterin überwacht gleichzeitig maximal ein Spiel (0..1).

Prüfungshinweis: Multiplizitäten spielen in Use-Case-Diagrammen in der Praxis eine untergeordnete Rolle, da sie das Diagramm schnell überladen. Ihre volle konzeptionelle Bedeutung entfalten sie erst im strukturellen Klassendiagramm.

Abhängigkeiten zwischen Anwendungsfällen

Include-Beziehung (<<include>>)

Die include-Beziehung dient der Vermeidung von Redundanz. Sie lagert gemeinsames Verhalten in einen eigenen Use Case aus. Der gestrichelte Pfeil zeigt vom Basis-Use-Case zum inkludierten Use Case.

  • Semantik: Wenn der Basis-Anwendungsfall ausgeführt wird, wird der inkludierte Anwendungsfall zwingend immer (zu 100%) mit ausgeführt. Der Basis-Use-Case ist ohne das Inkludat unvollständig.
Include-Beziehung: Der inkludierte Prozess wird zwingend aufgerufen.

Extend-Beziehung (<<extend>>)

Die extend-Beziehung modelliert Ausnahmebehandlungen oder optionale Erweiterungen. Der gestrichelte Pfeil zeigt (im Gegensatz zum Include!) vom erweiternden Use Case (Extension) zurück auf den Basis-Use-Case.

  • Semantik: Die Erweiterung wird nur unter bestimmten Bedingungen ausgeführt. Der Basis-Use-Case ist auch ohne die Erweiterung vollständig lauffähig.

Die Integration erfolgt über sogenannte Erweiterungspunkte (Extension Points). Diese markieren im Basis-Use-Case (unterhalb eines Trennstrichs) die genaue Stelle des Eingriffs. Optional kann über ein Notizsymbol eine logische Bedingung (Condition) angefügt werden, die prüft, ob die Erweiterung überhaupt zündet.

Extend-Beziehung mit definierten Erweiterungspunkten und auslösender Bedingung (Condition).

Generalisierung (Vererbung)

Die Generalisierung entspricht dem aus der Objektorientierung bekannten Konzept der Vererbung ("Ist-ein"-Beziehung). Sie wird mit einer durchgehenden Linie und einer hohlen, geschlossenen Pfeilspitze dargestellt, die vom speziellen zum allgemeinen Element zeigt.

Generalisierungsbeziehung: Spezialisierung von Anwendungsfällen oder Akteuren.
  • Generalisierung von Akteuren: Der Akteur Fahrer ist eine Spezialisierung des Akteurs Anwender. Der Fahrer erbt alle Zugriffsrechte und Use Cases des allgemeinen Anwenders (z. B. "Login"), besitzt darüber hinaus aber erweiterte, spezifische Berechtigungen (z. B. "Fahrzeug starten").
  • Generalisierung von Use Cases: Ein allgemeiner Anwendungsfall wie „Zahlung durchführen“ kann durch spezialisierte Anwendungsfälle wie „Per Kreditkarte zahlen“ oder „Per PayPal zahlen“ generalisiert werden. Die speziellen Fälle erben die grundlegende Funktionalität, setzen sie aber im Detail abweichend um.