UML – Klassen-, Aktivitäts- und Sequenzdiagramm#

UML (Unified Modeling Language) ist eine standardisierte Notation zur grafischen Modellierung von Software. Für die Prüfung sind drei Diagrammtypen besonders relevant: das Klassendiagramm (statische Struktur), das Aktivitätsdiagramm (Abläufe/Algorithmen) und das Sequenzdiagramm (zeitlicher Nachrichtenaustausch zwischen Objekten).

Klassendiagramm#

Das Klassendiagramm zeigt die statische Struktur eines Systems: welche Klassen es gibt, welche Attribute/Methoden sie haben und wie sie zueinander in Beziehung stehen.

Notation – Die Klassenbox#

┌─────────────────────┐
│      Kunde           │  ← Klassenname
├─────────────────────┤
│ - kundenNr: int       │  ← Attribute
│ - name: String        │
├─────────────────────┤
│ + bestellen(): void   │  ← Methoden/Operationen
│ + getKundenNr(): int  │
└─────────────────────┘

Sichtbarkeiten (Visibility):

Beziehungen zwischen Klassen#

Beispiel: Bestellsystem#

classDiagram
  class Kunde {
    -kundenNr: int
    -name: String
    +bestellen(): void
  }
  class Bestellung {
    -bestellNr: int
    -datum: Date
    +berechneSumme(): float
  }
  class Artikel {
    -artikelNr: int
    -preis: float
  }
  class Firmenkunde {
    -firmenname: String
  }

  Kunde "1" -- "0..*" Bestellung : gibt auf
  Bestellung "1" o-- "1..*" Artikel : enthält
  Firmenkunde --|> Kunde : erbt von

Kunde "1" -- "0..*" Bestellung liest sich: ein Kunde kann null bis viele Bestellungen aufgeben. Firmenkunde --|> Kunde ist die Vererbung (Firmenkunde ist ein Spezialfall von Kunde).

Aktivitätsdiagramm#

Das Aktivitätsdiagramm ist ein UML-Diagrammtyp zur grafischen Darstellung von Abläufen, Prozessen und Algorithmen. Es zeigt den Kontrollfluss durch Aktionen, Verzweigungen und Schleifen.

Notation – Die Bausteine#

Grundstruktur#

        ●
        │
        ▼
  ┌─────────────┐
  │  Aktion 1   │
  └─────────────┘
        │
        ▼
       ◇
      / \
[Ja]/   \[Nein]
   /     \
  ▼       ▼
┌───┐   ┌───┐
│ A │   │ B │
└───┘   └───┘
  \     /
   \   /
    ▼ ▼
     ◇   ← Zusammenführung
     │
     ▼
    ◉

Vollständiges Beispiel: Login-Prozess#

              ●
              │
              ▼
  ┌─────────────────────┐
  │  Anmeldemaske       │
  │  anzeigen           │
  └─────────────────────┘
              │
              ▼
  ┌─────────────────────┐
  │  Benutzerdaten      │
  │  eingeben           │
  └─────────────────────┘
              │
              ▼
             ◇
            / \
  [gültig] /   \ [ungültig]
          /     \
         ▼       ▼
  ┌──────────┐  ┌─────────────────┐
  │  Zugang  │  │  Fehlermeldung  │
  │  gewähren│  │  anzeigen       │
  └──────────┘  └─────────────────┘
         │              │
         │       ┌──────┘
         │       │  [Versuche < 3]
         │       ▼
         │      ◇
         │     / \
         │    /   \ [Versuche >= 3]
         │   /     \
         │  ▼       ▼
         │ (zurück   ┌──────────────┐
         │  zur      │  Konto       │
         │  Eingabe) │  sperren     │
         │           └──────────────┘
         │                 │
         └────────┬─────────┘
                  ▼
                 ◉

Parallele Abläufe (Fork & Join)#

Wenn mehrere Aktionen gleichzeitig ausgeführt werden:

              │
              ▼
    ══════════════════  ← Fork (Aufspaltung)
       │            │
       ▼            ▼
  ┌─────────┐  ┌──────────┐
  │ Drucker │  │  E-Mail  │
  │ starten │  │ versenden│
  └─────────┘  └──────────┘
       │            │
       ▼            ▼
    ══════════════════  ← Join (beide müssen fertig sein)
              │
              ▼

Swimlanes (Verantwortungsbereiche)#

Swimlanes teilen das Diagramm in Zuständigkeitsbereiche auf:

│      Kunde          │        System         │
│─────────────────────│─────────────────────  │
│         ●           │                       │
│         │           │                       │
│         ▼           │                       │
│  ┌────────────┐     │                       │
│  │ Bestellung │     │                       │
│  │ aufgeben   │     │                       │
│  └────────────┘     │                       │
│         │           │                       │
│         └───────────┼──►┌────────────────┐  │
│                     │   │ Bestellung     │  │
│                     │   │ verarbeiten    │  │
│                     │   └────────────────┘  │
│                     │          │            │
│  ┌──────────────┐◄──┼──────────┘            │
│  │ Bestätigung  │   │                       │
│  │ erhalten     │   │                       │
│  └──────────────┘   │                       │
│         │           │                       │
│         ▼           │                       │
│        ◉            │                       │

Aktivitätsdiagramm vs. Programmcode#

Das Aktivitätsdiagramm entspricht direkt den Kontrollstrukturen der Programmierung:

Beispiel: Schleife im Aktivitätsdiagramm

              ●
              │
              ▼
  ┌─────────────────┐
  │  i = 0          │
  └─────────────────┘
              │
              ▼
             ◇ ◄───────────────────┐
            / \                    │
    [i < 5]/   \[i >= 5]           │
          /     \                  │
         ▼       ▼           ┌─────────────┐
  ┌──────────┐   │           │  i = i + 1  │
  │ Ausgabe  │   │           └─────────────┘
  │ i        │   │                 ▲
  └──────────┘   │                 │
         │       │                 │
         └───────────────────────►─┘
                 │
                 ▼
                ◉

→ Entspricht: for (int i = 0; i < 5; i++) { System.out.println(i); }

Prüfungstipps#

• Startknoten: Immer genau einen ● am Anfang
• Endknoten: Kann mehrere ◉ geben (z.B. bei Fehlerabbruch)
• Bedingungen an allen Ausgangspfeilen eines Entscheidungsknotens beschriften [Bedingung]
• Alle Pfade müssen irgendwo enden (kein offener Pfeil)
• Swimlanes sind optional, aber gut für Prüfungsaufgaben mit mehreren Beteiligten

Sequenzdiagramm#

Das Sequenzdiagramm zeigt den zeitlichen Ablauf von Nachrichten zwischen Objekten — wer ruft wen wann auf. Anders als das Aktivitätsdiagramm (Kontrollfluss) steht hier die Kommunikation zwischen Objekten im Vordergrund.

Notation – Die Bausteine#

Beispiel: Login-Ablauf#

sequenceDiagram
  actor Nutzer
  participant UI as Anmeldemaske
  participant Server
  participant DB as Datenbank

  Nutzer->>UI: Benutzerdaten eingeben
  UI->>Server: login(user, pw)
  Server->>DB: Nutzer suchen
  DB-->>Server: Nutzerdatensatz
  alt Zugangsdaten gültig
    Server-->>UI: Zugang gewähren
    UI-->>Nutzer: Weiterleitung zur Startseite
  else Zugangsdaten ungültig
    Server-->>UI: Fehler
    UI-->>Nutzer: Fehlermeldung anzeigen
  end

Der alt/else-Rahmen entspricht genau dem Entscheidungsknoten (◇) im Aktivitätsdiagramm — nur dass hier die Nachrichten zwischen konkreten Objekten (Nutzer, UI, Server, Datenbank) im zeitlichen Verlauf sichtbar sind.

Aktivitätsdiagramm vs. Sequenzdiagramm#

Prüfungsbeispiele#

„Zeichne ein Aktivitätsdiagramm für: Ein Nutzer gibt eine Zahl ein. Ist die Zahl positiv, wird sie verdoppelt und ausgegeben. Ist sie negativ, wird eine Fehlermeldung angezeigt."

        ●
        │
        ▼
  ┌──────────────┐
  │ Zahl einlesen│
  └──────────────┘
        │
        ▼
       ◇
      / \
[> 0]/   \[<= 0]
    /     \
   ▼       ▼
┌───────┐ ┌────────────────┐
│Zahl × 2│ │Fehlermeldung  │
│ausgeben│ │anzeigen       │
└───────┘ └────────────────┘
    │             │
    └──────┬──────┘
           ▼
          ◉

„Was ist der Unterschied zwischen einem Entscheidungsknoten und einem Fork?"

→ Entscheidungsknoten (◇): Nur ein Pfad wird weiterverfolgt (Bedingung wählt den Weg). Fork (═══): Alle Pfade werden gleichzeitig/parallel ausgeführt.

„Modelliere im Klassendiagramm: Ein Auto hat einen Motor (Komposition — ohne Auto kein Motor) und kann mehreren Personen gehören (Assoziation)."

→ Auto *-- Motor (Komposition, ausgefüllte Raute an der Auto-Seite) und Auto "0..*" -- "1..*" Person (Assoziation mit Multiplizität auf beiden Seiten).

„Was ist der Unterschied zwischen Aggregation und Komposition?"

→ Aggregation (◇): Das Teil kann unabhängig vom Ganzen existieren und auch zu einem anderen Ganzen gehören (ein Spieler existiert auch ohne Team). Komposition (◆): Das Teil existiert nur innerhalb des Ganzen — wird das Ganze gelöscht, verschwindet auch das Teil (ein Zimmer existiert nicht ohne das Haus).

„Warum zeigt ein Sequenzdiagramm einen Login-Vorgang besser als ein Aktivitätsdiagramm?"

→ Weil beim Login mehrere Objekte (UI, Server, Datenbank) miteinander kommunizieren — das Sequenzdiagramm macht sichtbar, welches Objekt welche Nachricht an welches andere Objekt schickt und in welcher Reihenfolge. Das Aktivitätsdiagramm zeigt nur den Kontrollfluss, aber nicht, welches Objekt welchen Schritt ausführt.

Quiz#

Siehe auch#

• softwaredokumentation — UML-Diagramme als Bestandteil der technischen Dokumentation
• testverfahren — Aktivitätsdiagramme helfen, alle Testpfade (Branch Coverage) zu identifizieren
• agile methoden — Prozessmodellierung in der Anforderungsanalyse und Planung
• erm — Klassendiagramm vs. ERM als zwei Notationen für Datenstrukturen

Ressourcen#

• Wikipedia: Aktivitätsdiagramm
• Wikipedia: Klassendiagramm
• Wikipedia: Sequenzdiagramm
• Wikipedia: Unified Modeling Language
• Studyflix: UML Aktivitätsdiagramm / Klassendiagramm / Sequenzdiagramm einfach erklärt
• SimpleClub: UML Diagramme auf YouTube suchen