UML Diagramme: Klassen-, Sequenz-, Aktivitäts- & UseCase-Diagramme

Dieser Beitrag ist eine umfassende Übersicht der UML-Diagramme – inklusive aller wichtigen Diagrammtypen, Beziehungen und praktischer Beispiele.

In a Nutshell

UML (Unified Modeling Language) ist die standardisierte grafische Notation zur Modellierung von Softwaresystemen, die verschiedene Diagrammtypen für unterschiedliche Aspekte der Softwareentwicklung bereitstellt.

Kompakte Fachbeschreibung

Unified Modeling Language (UML) ist eine von der Object Management Group (OMG) standardisierte Modellierungssprache für objektorientierte Softwareentwicklung.

Hauptdiagrammtypen:

• Strukturdiagramme: Statische Aspekte (Klassen, Komponenten, Deployment)
• Verhaltensdiagramme: Dynamische Aspekte (Aktivitäten, Sequenzen, Zustände)
• Interaktionsdiagramme: Kommunikation zwischen Objekten

Wichtigste Diagramme:

• Klassendiagramm: Klassen, Attribute, Methoden, Beziehungen
• Sequenzdiagramm: Zeitliche Abläufe und Nachrichtenfluss
• Aktivitätsdiagramm: Prozessabläufe und Entscheidungen
• UseCase-Diagramm: Anforderungen und Akteursinteraktionen

UML dient als Kommunikationsmittel zwischen Entwicklern, Architekten und Stakeholdern und bildet die Grundlage für Codegenerierung und Dokumentation.

Prüfungsrelevante Stichpunkte

• Klassendiagramm: Statische Struktur mit Attributen, Methoden, Beziehungen
• Sequenzdiagramm: Zeitliche Interaktionen zwischen Objekten
• Aktivitätsdiagramm: Prozessabläufe mit Entscheidungen und Parallelität
• UseCase-Diagramm: Funktionalanforderungen und Akteursinteraktionen
• Beziehungen: Assoziation, Aggregation, Komposition, Vererbung
• Sichtbarkeitsmodifizierer: public (+), private (-), protected (#), package (~)
• Multiplizitäten: 1, , 0..1, 1.., 0..*
• IHK-relevant für Softwarearchitektur und -design

Kernkomponenten

Klassendiagramm

1. Klassen: Rechtecke mit Name, Attributen, Methoden
2. Attribute: Eigenschaften mit Typ und Sichtbarkeit
3. Methoden: Operationen mit Parametern und Rückgabetyp
4. Beziehungen: Verbindungen zwischen Klassen

Sequenzdiagramm

1. Akteure: Teilnehmer der Interaktion
2. Lebenslinien: Vertikale Linien für Objekte
3. Nachrichten: Horizontale Pfeile zwischen Lebenslinien
4. Aktivierungsboxen: Rechtecke auf Lebenslinien

Aktivitätsdiagramm

1. Aktionen: Abgerundete Rechtecke
2. Entscheidungen: Rauten für Verzweigungen
3. Start/End: Kreise für Prozessbeginn/-ende
4. Synchronisationsbalken: Für parallele Abläufe

UseCase-Diagramm

1. UseCases: Ovale für Funktionalitäten
2. Akteure: Stickfiguren für Benutzer/Rollen
3. Systemgrenzen: Rechtecke um UseCases
4. Beziehungen: Linien zwischen Akteuren und UseCases

Praxisbeispiele

1. Klassendiagramm (E-Commerce System)

@startuml ECommerceClassDiagram

class Kunde {
  -kundenId: Long
  -name: String
  -email: String
  -adresse: String
  +getKundenId(): Long
  +bestellen(produktId: Long, menge: Int): Bestellung
  +getBestellungen(): List<Bestellung>
}

class Bestellung {
  -bestellId: Long
  -bestelldatum: Date
  -gesamtbetrag: Decimal
  -status: String
  +berechneGesamtbetrag(): Decimal
  +setStatus(status: String): void
  +getPositionen(): List<Bestellposition>
}

class Produkt {
  -produktId: Long
  -name: String
  -preis: Decimal
  -lagerbestand: Int
  +getPreis(): Decimal
  +pruefeVerfuegbarkeit(menge: Int): Boolean
  +reduziereLagerbestand(menge: Int): void
}

class Bestellposition {
  -positionsId: Long
  -menge: Int
  -einzelpreis: Decimal
  +berechneGesamtpreis(): Decimal
}

' Beziehungen
Kunde "1" -- "0..*" Bestellung : erstellt >
Bestellung "1" -- "1..*" Bestellposition : enthält >
Bestellung "1" -- "*" Produkt : bezieht sich auf >
Produkt "0..*" -- "0..*" Bestellposition : wird bestellt >

@enduml

2. Sequenzdiagramm (Bestellprozess)

@startuml BestellSequenzDiagramm

actor Kunde
participant "BestellService" as Service
participant "ProduktService" as Produkt
participant "ZahlungsService" as Zahlung
participant "LagerService" as Lager

Kunde -> Service: bestelleProdukte(produkte, menge)
activate Service

Service -> Produkt: pruefeProdukte(produkte)
activate Produkt
Produkt --> Service: verfuegbarkeitsInfo
deactivate Produkt

alt alle Produkte verfügbar
    Service -> Lager: reserviereLager(produkte, menge)
    activate Lager
    Lager --> Service: reservierungsBestaetigung
    deactivate Lager
    
    Service -> Zahlung: verarbeiteZahlung(kunde, betrag)
    activate Zahlung
    Zahlung --> Service: zahlungsBestaetigung
    deactivate Zahlung
    
    Service -> Lager: bestätigeReservierung(reservierungsId)
    activate Lager
    Lager --> Service: bestätigungErfolgt
    deactivate Lager
    
    Service --> Kunde: bestellBestaetigung(bestellId)
else Produkte nicht verfügbar
    Service --> Kunde: verfuegbarkeitsFehlerr(produkte)
end

deactivate Service

@enduml

3. Aktivitätsdiagramm (Bestellabwicklung)

@startuml BestellAktivitaetsDiagramm

start

:Bestellung eingegangen;

if (Produkt verfügbar?) then (ja)
  :Lagerbestand prüfen;
  
  fork
    :Zahlung verarbeiten;
  fork again
    :Lieferadresse prüfen;
  end fork
  
  if (Zahlung erfolgreich?) then (ja)
    :Bestellung bestätigen;
    :Lagerbestand reduzieren;
    :Versand veranlassen;
    stop
  else (nein)
    :Bestellung ablehnen;
    :Lagerreservierung aufheben;
    stop
  endif
else (nein)
  :Verfügbarkeitsfehler melden;
  :Alternative Produkte vorschlagen;
  stop
endif

@enduml

4. UseCase-Diagramm (E-Commerce System)

@startuml ECommerceUseCaseDiagram

actor Kunde
actor Administrator
actor Lieferant

rectangle "E-Commerce System" {
  usecase "Produkt suchen" as UC1
  usecase "Produkt ansehen" as UC2
  usecase "Warenkorb verwalten" as UC3
  usecase "Bestellung aufgeben" as UC4
  usecase "Bestellung verfolgen" as UC5
  usecase "Bewertung abgeben" as UC6
  usecase "Produkt verwalten" as UC7
  usecase "Bestellungen bearbeiten" as UC8
  usecase "Lieferung verwalten" as UC9
}

' Beziehungen
Kunde --> UC1
Kunde --> UC2
Kunde --> UC3
Kunde --> UC4
Kunde --> UC5
Kunde --> UC6

Administrator --> UC7
Administrator --> UC8

Lieferant --> UC9

' Include-Beziehungen
UC4 --> UC3 : <<include>>
UC4 --> UC2 : <<include>>

' Extend-Beziehungen
UC6 --> UC4 : <<extend>>

@enduml

5. Java Code aus Klassendiagramm generiert

// Kunde.java
public class Kunde {
    private Long kundenId;
    private String name;
    private String email;
    private String adresse;
    private List<Bestellung> bestellungen = new ArrayList<>();
    
    public Long getKundenId() {
        return kundenId;
    }
    
    public Bestellung bestellen(Long produktId, int menge) {
        Bestellung bestellung = new Bestellung();
        bestellung.setBestelldatum(new Date());
        // Bestellposition hinzufügen
        Bestellposition position = new Bestellposition();
        position.setMenge(menge);
        bestellung.addPosition(position);
        
        bestellungen.add(bestellung);
        return bestellung;
    }
    
    public List<Bestellung> getBestellungen() {
        return new ArrayList<>(bestellungen);
    }
}

// Bestellung.java
public class Bestellung {
    private Long bestellId;
    private Date bestelldatum;
    private BigDecimal gesamtbetrag;
    private String status;
    private List<Bestellposition> positionen = new ArrayList<>();
    
    public BigDecimal berechneGesamtbetrag() {
        return positionen.stream()
            .map(Bestellposition::berechneGesamtpreis)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
    
    public void setStatus(String status) {
        this.status = status;
    }
    
    public List<Bestellposition> getPositionen() {
        return new ArrayList<>(positionen);
    }
    
    public void addPosition(Bestellposition position) {
        positionen.add(position);
    }
}

// Produkt.java
public class Produkt {
    private Long produktId;
    private String name;
    private BigDecimal preis;
    private int lagerbestand;
    
    public BigDecimal getPreis() {
        return preis;
    }
    
    public boolean pruefeVerfuegbarkeit(int menge) {
        return lagerbestand >= menge;
    }
    
    public void reduziereLagerbestand(int menge) {
        if (pruefeVerfuegbarkeit(menge)) {
            lagerbestand -= menge;
        } else {
            throw new IllegalArgumentException("Nicht genügend Lagerbestand");
        }
    }
}

// Bestellposition.java
public class Bestellposition {
    private Long positionsId;
    private int menge;
    private BigDecimal einzelpreis;
    
    public BigDecimal berechneGesamtpreis() {
        return einzelpreis.multiply(new BigDecimal(menge));
    }
}

UML Beziehungen im Detail

Assoziation

Kunde 1..* --* Bestellung

• Beide Klassen voneinander abhängig
• Lebenszyklus unabhängig

Aggregation

Fahrzeug 1 --* Reifen

• Reifen können ohne Fahrzeug existieren
• “hat-ein” Beziehung

Komposition

Auto 1 --* Motor

• Motor existiert nur mit Auto
• “ist-Teil-von” Beziehung

Vererbung

Fahrzeug <|-- Auto

• Auto erbt von Fahrzeug
• “ist-ein” Beziehung

Implementierung

Interface <|.. Klasse

• Klasse implementiert Interface
• Realisierungsbeziehung

Multiplizitäten

Symbol	Bedeutung	Beispiel
1	Genau eins	1 Kunde
0..1	Null oder eins	0..1 Adresse
*	Null oder mehr	* Bestellungen
1..*	Mindestens eins	1..* Positionen
0..*	Null bis beliebig viele	0..* Produkte
2..4	Zwischen 2 und 4	2..4 Räder

Sichtbarkeitsmodifizierer

Symbol	Bedeutung	Beschreibung
+	public	Von überall zugreifbar
-	private	Nur innerhalb der Klasse
#	protected	Innerhalb Klasse und Unterklassen
~	package	Innerhalb des Packages

Vorteile und Nachteile

Vorteile von UML

• Standardisierung: Einheitliche Notation für alle
• Visualisierung: Komplexe Zusammenhänge verständlich
• Kommunikation: Gemeinsame Sprache für Team
• Dokumentation: Automatische Generierung möglich
• Code-Generierung: Direkte Umsetzung in Code

Nachteile

• Komplexität: Bei sehr großen Systemen unübersichtlich
• Lernkurve: Erfordert Einarbeitungszeit
• Over-Engineering: Zu detaillierte Modellierung
• Wartung: Änderungen erfordern Diagrammanpassung

Häufige Prüfungsfragen

1. Was ist der Unterschied zwischen Aggregation und Komposition? Aggregation: “hat-ein” (Teile können unabhängig existieren), Komposition: “ist-Teil-von” (Teile existieren nur mit dem Ganzen).

2. Erklären Sie die Multiplizitäten 1.. und 0..1!* 1..*: Mindestens eins, beliebig viele. 0..1: Null oder genau eins.

3. Wann verwendet man Sequenzdiagramme? Zur Darstellung zeitlicher Abläufe und Interaktionen zwischen Objekten.

4. Was ist der Zweck von UseCase-Diagrammen? Anforderungen aus Sicht der Benutzer/Akteure modellieren.

Wichtigste Quellen

1. https://www.uml.org/
2. https://de.wikipedia.org/wiki/Unified_Modeling_Language
3. https://plantuml.com/