# Seite 9. UML-Aktivitätsdiagramm
Diese Seite erklärt das **UML-Aktivitätsdiagramm** so, dass du es schnell für IHK-Aufgaben und Programmierlogik anwenden kannst.
Ein UML-Aktivitätsdiagramm wird benutzt, um **Abläufe** darzustellen.
Es zeigt:
```text
Start
Aktionen
Entscheidungen
Bedingungen
Kontrollflüsse
Merge-Knoten
Ende
```
---
**Grafik 1: UML-Aktivitätsdiagramm – Grundlagen**
Diese Grafik zeigt dir die wichtigsten Symbole:
- **Startknoten**
- **Aktion / Aktivität**
- **Entscheidung**
- **Merge-Knoten**
- **Kontrollfluss**
- **Endknoten**
Wichtig für die Prüfung:
```text
Eine Entscheidung hat meistens einen Eingang und mehrere Ausgänge.
Ein Merge-Knoten führt mehrere alternative Wege wieder zusammen.
```
---
**Wofür braucht man ein UML-Aktivitätsdiagramm?**
Ein Aktivitätsdiagramm zeigt einen Ablauf Schritt für Schritt.
Typische Beispiele:
```text
Login prüfen
Bestellung bearbeiten
Produktdaten speichern
Eingabe validieren
Fehler anzeigen
Zurück ins Menü
```
Es ist besonders hilfreich, wenn ein Ablauf Entscheidungen enthält.
Beispiel:
```text
Wenn die Eingabe gültig ist, wird gespeichert.
Wenn die Eingabe ungültig ist, wird eine Fehlermeldung angezeigt.
```
---
**Woran erkenne ich in einer Aufgabe, dass ein UML-Aktivitätsdiagramm gemeint ist?**
Typische Signalwörter:
| Signalwort / Formulierung | Hinweis |
|---|---|
| Ablauf | Schritte sollen dargestellt werden |
| Prozess | Reihenfolge von Tätigkeiten |
| Entscheidung | meistens Raute |
| wenn / sonst | Verzweigung im Ablauf |
| prüfen | häufig Entscheidung danach |
| gültig / ungültig | typische Guard-Bedingungen |
| ja / nein | Entscheidungsausgänge |
| Schleife | Rücksprung im Ablauf |
| Kontrollfluss | Pfeile zwischen Aktionen |
| „stellen Sie den Ablauf dar“ | oft Aktivitätsdiagramm |
---
**Grundsymbole**
| Symbol | Bedeutung | Darstellung |
|---|---|---|
| **Startknoten** | Beginn des Ablaufs | gefüllter Kreis |
| **Aktion / Aktivität** | auszuführender Schritt | abgerundetes Rechteck |
| **Entscheidung** | Verzweigung im Ablauf | Raute |
| **Merge-Knoten** | Zusammenführung alternativer Pfade | Raute |
| **Kontrollfluss** | Ablaufreihenfolge | Pfeil |
| **Endknoten** | Ende des Ablaufs | Kreis mit gefülltem Punkt |
---
**Startknoten**
Der Startknoten zeigt, wo der Ablauf beginnt.
Darstellung:
```text
●
```
Merksatz:
```text
Start = gefüllter Kreis
```
Ein Aktivitätsdiagramm hat meistens genau einen klaren Startpunkt.
---
**Aktion / Aktivität**
Eine Aktion ist ein konkreter Arbeitsschritt.
Beispiele:
```text
Produktdaten eingeben
Eingabe prüfen
Produkt speichern
Fehler anzeigen
Zurück ins Menü
```
Darstellung:
```text
( Produktdaten eingeben )
```
Im Diagramm wird dafür normalerweise ein **abgerundetes Rechteck** verwendet.
---
**Kontrollfluss**
Ein Kontrollfluss zeigt die Reihenfolge der Schritte.
Darstellung:
```text
Aktion 1 → Aktion 2
```
Wichtig:
```text
Der Pfeil zeigt, welcher Schritt als Nächstes kommt.
```
---
**Entscheidung**
Eine Entscheidung wird verwendet, wenn der Ablauf in verschiedene Richtungen gehen kann.
Darstellung:
```text
◇
```
Beispiel:
```text
Eingabe gültig?
```
Danach gibt es meistens zwei Wege:
```text
[ja]
[nein]
```
Wichtig:
```text
Die Bedingungen an den ausgehenden Pfeilen heißen Guards.
```
---
**Guards**
Guards sind Bedingungen an Kontrollflüssen.
Typische Schreibweise:
```text
[ja]
[nein]
[gültig]
[ungültig]
[preis > 0]
[eingabe leer]
```
Beispiel:
```text
Eingabe gültig?
[ja] → Produkt speichern
[nein] → Fehler anzeigen
```
Für Prüfungen ist wichtig:
```text
Bedingungen sollten an den Pfeilen stehen, nicht nur irgendwo im Diagramm.
```
---
**Merge-Knoten**
Ein Merge-Knoten führt alternative Wege wieder zusammen.
Darstellung:
```text
◇
```
Wichtig:
```text
Entscheidung und Merge benutzen beide eine Raute.
```
Der Unterschied:
| Element | Bedeutung |
|---|---|
| **Entscheidung** | ein Eingang, mehrere Ausgänge |
| **Merge-Knoten** | mehrere Eingänge, ein Ausgang |
Beispiel:
```text
[ja] → Produkt speichern ┐
◇ → Zurück ins Menü
[nein] → Fehler anzeigen ┘
```
---
**Endknoten**
Der Endknoten zeigt das Ende des Ablaufs.
Darstellung:
```text
◎
```
Merksatz:
```text
Ende = Kreis mit gefülltem Punkt
```
---
**Grafik 2: Beispiel – Produkt speichern**
Diese Grafik zeigt einen typischen Ablauf:
```text
Produktdaten eingeben
Eingabe prüfen
Entscheidung: Eingabe gültig?
[ja] → Produkt speichern
[nein] → Fehler anzeigen
Merge-Knoten
Zurück ins Menü
Ende
```
Wichtig:
```text
Die Verzweigung wird mit einer Entscheidungsraute dargestellt.
Die Zusammenführung wird mit einem Merge-Knoten dargestellt.
Die Bedingungen stehen als [ja] und [nein] an den Kontrollflüssen.
```
---
**Beispiel als Textablauf**
Aufgabe:
```text
Ein Benutzer gibt Produktdaten ein.
Das System prüft die Eingabe.
Wenn die Eingabe gültig ist, wird das Produkt gespeichert.
Wenn die Eingabe ungültig ist, wird eine Fehlermeldung angezeigt.
Danach kehrt das System ins Menü zurück.
```
Daraus entsteht:
```text
Start
↓
Produktdaten eingeben
↓
Eingabe prüfen
↓
Eingabe gültig?
├─ [ja] → Produkt speichern
└─ [nein] → Fehler anzeigen
↓
Merge
↓
Zurück ins Menü
↓
Ende
```
---
**Entscheidung vs. Merge**
| Merkmal | Entscheidung | Merge |
|---|---|---|
| Symbol | Raute | Raute |
| Eingänge | meistens 1 | mehrere |
| Ausgänge | mehrere | meistens 1 |
| Zweck | Ablauf verzweigt sich | alternative Wege kommen zusammen |
| Beispiel | Eingabe gültig? | nach Speichern oder Fehleranzeige weiter |
Merksatz:
```text
Entscheidung teilt den Ablauf.
Merge führt alternative Wege wieder zusammen.
```
---
**Aktivitätsdiagramm vs. Programmcode**
Ein Aktivitätsdiagramm passt gut zu `if`-Anweisungen.
Beispiel Code-Logik:
```java
if (eingabeGueltig) {
produktSpeichern();
} else {
fehlerAnzeigen();
}
zurueckInsMenue();
```
Passendes Aktivitätsdiagramm:
```text
Eingabe prüfen
↓
Eingabe gültig?
├─ [ja] → Produkt speichern
└─ [nein] → Fehler anzeigen
↓
Merge
↓
Zurück ins Menü
```
---
**Typische Kontrollstrukturen**
| Kontrollstruktur | Darstellung im Aktivitätsdiagramm |
|---|---|
| Sequenz | Aktionen nacheinander |
| Entscheidung | Raute mit Guards |
| Alternative | [ja] / [nein] |
| Schleife | Rückpfeil zu früherer Aktion |
| Zusammenführung | Merge-Knoten |
| Ende | Endknoten |
---
**Schleifen im Aktivitätsdiagramm**
Eine Schleife entsteht, wenn ein Ablauf zu einem früheren Schritt zurückführt.
Beispiel:
```text
Eingabe prüfen
↓
Eingabe gültig?
├─ [ja] → Speichern
└─ [nein] → Fehler anzeigen → Eingabe erneut bearbeiten
```
Merksatz:
```text
Schleifen erkennt man an einem Rückpfeil im Ablauf.
```
---
**Vorgehensweise in der Prüfung**
Wenn du ein UML-Aktivitätsdiagramm erstellen sollst, gehe so vor:
| Schritt | Frage |
|---|---|
| 1 | Wo beginnt der Ablauf? |
| 2 | Welche Aktionen passieren nacheinander? |
| 3 | Gibt es eine Entscheidung? |
| 4 | Welche Bedingungen stehen an den Ausgängen? |
| 5 | Gibt es alternative Wege? |
| 6 | Müssen Wege wieder zusammengeführt werden? |
| 7 | Gibt es eine Schleife oder einen Rücksprung? |
| 8 | Wo endet der Ablauf? |
---
**Typische IHK-Fehler**
| Fehler | Warum problematisch? |
|---|---|
| Startknoten vergessen | Ablauf hat keinen klaren Beginn |
| Endknoten vergessen | Ablauf wirkt unvollständig |
| Entscheidung ohne Bedingungen | nicht klar, welcher Weg wann gilt |
| Guards nicht in eckigen Klammern | weniger UML-sauber |
| Merge fehlt | alternative Wege werden unsauber zusammengeführt |
| Aktion als Raute gezeichnet | Aktion ist keine Entscheidung |
| Entscheidung als Rechteck gezeichnet | Verzweigung wird falsch dargestellt |
| Pfeilrichtung falsch | Ablaufreihenfolge ist unklar |
| Zu viel Text in einer Aktion | Aktionen sollten kurz und eindeutig sein |
---
**Prüfungs-Merksätze**
```text
Start = gefüllter Kreis
Aktion = abgerundetes Rechteck
Entscheidung = Raute
Merge = Raute zum Zusammenführen
Ende = Kreis mit gefülltem Punkt
Kontrollfluss = Pfeil
Guards stehen an Pfeilen
Guards schreibt man oft in eckigen Klammern
[ja] und [nein] sind typische Guards
Entscheidung teilt Wege
Merge führt Wege zusammen
```
---
**Mini-Beispiel 1**
Aufgabe:
```text
Wenn ein Passwort korrekt ist, wird der Benutzer angemeldet.
Sonst wird eine Fehlermeldung angezeigt.
```
Lösungsidee:
```text
Start
↓
Passwort prüfen
↓
Passwort korrekt?
├─ [ja] → Benutzer anmelden
└─ [nein] → Fehlermeldung anzeigen
↓
Ende
```
---
**Mini-Beispiel 2**
Aufgabe:
```text
Ein Preis wird eingegeben.
Wenn der Preis größer als 0 ist, wird das Produkt gespeichert.
Sonst wird eine Fehlermeldung angezeigt.
```
Lösungsidee:
```text
Start
↓
Preis eingeben
↓
Preis > 0?
├─ [ja] → Produkt speichern
└─ [nein] → Fehler anzeigen
↓
Ende
```
---
**Mini-Beispiel 3**
Aufgabe:
```text
Ein Benutzer gibt Daten ein.
Wenn die Daten ungültig sind, soll er sie erneut eingeben.
Wenn sie gültig sind, werden sie gespeichert.
```
Lösungsidee:
```text
Start
↓
Daten eingeben
↓
Daten gültig?
├─ [ja] → Speichern → Ende
└─ [nein] → Fehler anzeigen → Daten eingeben
```
Hier entsteht eine Schleife, weil der Ablauf bei ungültigen Daten zurück zur Eingabe geht.
---
**Mini-Testfragen**
1. Wofür verwendet man ein UML-Aktivitätsdiagramm?
Ein UML-Aktivitätsdiagramm verwendet man, um Abläufe, Prozesse und Entscheidungen darzustellen.
Beispiele:
```text
Login prüfen
Produkt speichern
Bestellung bearbeiten
```
2. Wie wird der Startknoten dargestellt?
Der Startknoten wird als gefüllter Kreis dargestellt.
```text
●
```
3. Wie wird eine Aktion dargestellt?
Eine Aktion wird als abgerundetes Rechteck dargestellt.
Beispiel:
```text
Produkt speichern
```
4. Wie wird eine Entscheidung dargestellt?
Eine Entscheidung wird als Raute dargestellt.
Beispiel:
```text
Eingabe gültig?
```
5. Was sind Guards?
Guards sind Bedingungen an Kontrollflüssen.
Beispiele:
```text
[ja]
[nein]
[gültig]
[ungültig]
[preis > 0]
```
6. Was ist der Unterschied zwischen Entscheidung und Merge?
Eine Entscheidung teilt den Ablauf in mehrere Wege.
Ein Merge führt alternative Wege wieder zusammen.
```text
Entscheidung = 1 Eingang, mehrere Ausgänge
Merge = mehrere Eingänge, 1 Ausgang
```
7. Wie wird der Endknoten dargestellt?
Der Endknoten wird als Kreis mit gefülltem Punkt dargestellt.
```text
◎
```
8. Was zeigt ein Kontrollfluss?
Ein Kontrollfluss zeigt die Reihenfolge der Aktionen.
Er wird als Pfeil dargestellt.
9. Woran erkennt man eine Schleife?
Eine Schleife erkennt man daran, dass ein Pfeil zu einem früheren Schritt zurückführt.
Beispiel:
```text
Fehler anzeigen → Daten erneut eingeben
```
10. Welcher häufige Fehler passiert bei Entscheidungen?
Ein häufiger Fehler ist, die Bedingungen an den Ausgängen nicht zu beschriften.
Besser:
```text
[ja]
[nein]
```
---
**Nächste Seite**
Danach kommt die eigene Trainer-Seite:
```text
UML-Aktivitätsdiagramm-Trainer
```
Dort bauen wir den interaktiven Trainer mit Aufgaben zu:
```text
Startknoten erkennen
Aktionen eintragen
Entscheidungen setzen
Guards [ja]/[nein] ergänzen
Merge-Knoten verwenden
Endknoten korrekt platzieren
```