📐 UML Grundlagen

Informatik - Teil 6: Unified Modeling Language – Klassendiagramme verstehen und erstellen

1. Was ist UML?

📖 Definition

UML (Unified Modeling Language) ist eine standardisierte Modellierungssprache fĂŒr die Softwareentwicklung. Sie ermöglicht es, die Struktur und das Verhalten von Software grafisch darzustellen – unabhĂ€ngig von der Programmiersprache.

🎯 Warum UML?

  • Visualisierung: Komplexe Systeme grafisch verstĂ€ndlich machen
  • Kommunikation: Gemeinsame Sprache fĂŒr Entwickler, Designer und Kunden
  • Dokumentation: Software-Architektur dauerhaft festhalten
  • Planung: Struktur vor dem Programmieren entwerfen

📊 UML-Diagrammtypen (Überblick)

Kategorie Diagramm Beschreibt
Struktur Klassendiagramm Klassen, Attribute, Methoden, Beziehungen
Objektdiagramm Konkrete Objekte zu einem Zeitpunkt
Verhalten AktivitÀtsdiagramm Ablauf von AktivitÀten (Flussdiagramm)
Sequenzdiagramm Zeitliche Abfolge von Nachrichten
Use-Case-Diagramm AnwendungsfÀlle aus Nutzersicht

2. Klassendiagramme

📖 Was ist ein Klassendiagramm?

Ein Klassendiagramm zeigt die statische Struktur eines Systems: Welche Klassen gibt es, welche Attribute und Methoden haben sie, und wie stehen sie zueinander in Beziehung?

2.1 Aufbau einer Klasse

📩 Die drei Bereiche einer Klasse

Jede Klasse wird als Rechteck mit drei Bereichen dargestellt:

classDiagram class Klassenname { -attribut1: Datentyp -attribut2: Datentyp +methode1() RĂŒckgabetyp +methode2(param: Typ) RĂŒckgabetyp }
  • Oberer Bereich: Name der Klasse (fett, zentriert)
  • Mittlerer Bereich: Attribute (Variablen)
  • Unterer Bereich: Methoden (Funktionen)

2.2 Sichtbarkeit (Visibility)

🔐 Sichtbarkeitssymbole

Symbol Java-Keyword Bedeutung Zugriff von
+ public Öffentlich Überall
- private Privat Nur in eigener Klasse
# protected GeschĂŒtzt Eigene Klasse + Unterklassen
~ (default) Paket-sichtbar Gleiches Paket
Merkhilfe:
+ = Plus = Alle (öffentlich)
- = Minus = Abgezogen/Versteckt (privat)
# = Raute = GeschĂŒtzt (protected)

3. UML-Notation fĂŒr Attribute und Methoden

3.1 Attribute schreiben

📝 Attribut-Syntax

// UML-Format:
Sichtbarkeit name: Datentyp [= Standardwert]

// Beispiele:
- name: String
- alter: int = 0
+ id: int
# kontostand: double

Von UML nach Java

UML:

- name: String
- alter: int = 0
+ istAktiv: boolean

Java:

private String name;
private int alter = 0;
public boolean istAktiv;

3.2 Methoden schreiben

📝 Methoden-Syntax

// UML-Format:
Sichtbarkeit methodenname(parameter): RĂŒckgabetyp

// Beispiele:
+ getName(): String
+ setName(name: String): void
+ berechneAlter(geburtsjahr: int): int
- pruefePasswort(pw: String): boolean

Von UML nach Java

UML:

+ getName(): String
+ setAlter(a: int): void
- berechne(): double

Java:

public String getName()
public void setAlter(int a)
private double berechne()

3.3 Statische Elemente

📌 Statische Attribute und Methoden

Statische Elemente werden in UML unterstrichen dargestellt:

Zaehler
- anzahl: int
- name: String
+ getAnzahl(): int
+ getName(): String
// Entsprechender Java-Code:
public class Zaehler {
    private static int anzahl;  // unterstrichen = static
    private String name;
    
    public static int getAnzahl() {  // unterstrichen = static
        return anzahl;
    }
    
    public String getName() {
        return name;
    }
}

4. VollstÀndiges Klassendiagramm-Beispiel

Beispiel: Klasse Person

classDiagram class Person { -name: String -alter: int -email: String +Person(name: String, alter: int) +getName() String +setName(name: String) void +getAlter() int +setAlter(alter: int) void +getEmail() String +setEmail(email: String) void +toString() String }
public class Person {
    // Attribute (alle private)
    private String name;
    private int alter;
    private String email;
    
    // Konstruktor
    public Person(String name, int alter) {
        this.name = name;
        this.alter = alter;
    }
    
    // Getter und Setter
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAlter() {
        return alter;
    }
    
    public void setAlter(int alter) {
        this.alter = alter;
    }
    
    public String getEmail() {
        return email;
    }
    
    public void setEmail(String email) {
        this.email = email;
    }
    
    public String toString() {
        return name + " (" + alter + ")";
    }
}

5. Beziehungen zwischen Klassen

5.1 Assoziation

📖 Assoziation

Eine Assoziation beschreibt eine allgemeine Beziehung zwischen Klassen. Objekte einer Klasse "kennen" Objekte der anderen Klasse.

Darstellung: Einfache Linie zwischen den Klassen

🔗 Assoziation mit MultiplizitĂ€t

classDiagram Student "*" -- "*" Kurs : besucht class Student { -name: String -matrikelnr: int } class Kurs { -titel: String -credits: int }
MultiplizitÀt Bedeutung Beispiel
1 Genau eins Jede Person hat genau 1 Personalausweis
0..1 Null oder eins Person hat 0 oder 1 Auto
* oder 0..* Beliebig viele (inkl. 0) Person kann beliebig viele BĂŒcher haben
1..* Mindestens eins Kurs hat mindestens 1 Teilnehmer
n..m Zwischen n und m Team hat 2..11 Spieler

5.2 Aggregation ("hat"-Beziehung)

📖 Aggregation

Eine Aggregation ist eine "Teil-von"-Beziehung, bei der die Teile auch unabhÀngig vom Ganzen existieren können. Das Ganze "hat" seine Teile.

Darstellung: Linie mit leerer Raute ◇ am Ganzen

◇ Aggregation Beispiel

classDiagram Bibliothek o-- "*" Buch : hat class Bibliothek { -name: String -adresse: String +buchHinzufuegen(buch: Buch) } class Buch { -titel: String -autor: String -isbn: String }

Interpretation: Eine Bibliothek "hat" BĂŒcher. Wenn die Bibliothek schließt, existieren die BĂŒcher weiterhin.

In Mermaid: o-- = Aggregation (leere Raute)

public class Bibliothek {
    private ArrayList<Buch> buecher;
    
    public void buchHinzufuegen(Buch buch) {
        buecher.add(buch);
    }
}

5.3 Komposition ("besteht aus"-Beziehung)

📖 Komposition

Eine Komposition ist eine starke "Teil-von"-Beziehung. Die Teile können nicht ohne das Ganze existieren. Wenn das Ganze gelöscht wird, werden auch die Teile gelöscht.

Darstellung: Linie mit ausgefĂŒllter Raute ◆ am Ganzen

◆ Komposition Beispiel

classDiagram Haus *-- "1..*" Raum : besteht aus class Haus { -adresse: String -baujahr: int +Haus() } class Raum { -name: String -flaeche: double }

Interpretation: Ein Haus "besteht aus" RĂ€umen. Wenn das Haus abgerissen wird, existieren auch die RĂ€ume nicht mehr.

In Mermaid: *-- = Komposition (ausgefĂŒllte Raute)

public class Haus {
    private ArrayList<Raum> raeume = new ArrayList<>();
    
    // RĂ€ume werden im Haus erstellt
    public Haus() {
        raeume.add(new Raum("Wohnzimmer"));
        raeume.add(new Raum("KĂŒche"));
    }
}
Unterschied Aggregation vs. Komposition:
Aggregation (◇): "Hat" - Teile können unabhĂ€ngig existieren (Bibliothek hat BĂŒcher)
Komposition (◆): "Besteht aus" - Teile können NICHT unabhĂ€ngig existieren (Haus besteht aus RĂ€umen)

5.4 Vererbung (Generalisierung)

📖 Vererbung in UML

Die Vererbung zeigt eine "ist-ein"-Beziehung zwischen einer Oberklasse (Superklasse) und einer Unterklasse (Subklasse). Die Unterklasse erbt alle Attribute und Methoden der Oberklasse.

Darstellung: Linie mit leerem Dreieck △ zur Oberklasse

△ Vererbung Beispiel

classDiagram Fahrzeug <|-- Auto Fahrzeug <|-- Motorrad class Fahrzeug { #geschwindigkeit: int #marke: String +fahren() void +bremsen() void } class Auto { -anzahlTueren: int +hupen() void } class Motorrad { -hatBeiwagen: boolean +wheelie() void }

In Mermaid: <|-- = Vererbung (Dreieck zeigt zur Oberklasse)

public class Fahrzeug {
    protected int geschwindigkeit;
    protected String marke;
    
    public void fahren() { }
    public void bremsen() { }
}

public class Auto extends Fahrzeug {
    private int anzahlTueren;
    
    public void hupen() { }
}

public class Motorrad extends Fahrzeug {
    private boolean hatBeiwagen;
    
    public void wheelie() { }
}

6. Übersicht: Alle Beziehungen

📊 Beziehungen auf einen Blick

Beziehung Symbol Bedeutung Beispiel
Assoziation ——— "kennt" / allgemeine Verbindung Student — Kurs
Aggregation ◇——— "hat" / schwache Teil-Beziehung Team ◇— Spieler
Komposition ◆——— "besteht aus" / starke Teil-Beziehung Auto ◆— Motor
Vererbung ——△ "ist ein" / Spezialisierung Hund —△ Tier

7. Von Text zu UML

📝 Methodik: Textanalyse fĂŒr Klassendiagramme

  1. Substantive → Potenzielle Klassen
  2. Adjektive/Eigenschaften → Attribute
  3. Verben → Methoden
  4. "hat", "besteht aus" → Beziehungen
  5. "ist ein" → Vererbung

Beispiel: Text zu UML

Aufgabentext:

"Ein SchĂŒler hat einen Namen, eine Klasse und ein Alter. Er kann seine Noten berechnen und sich vorstellen."

Analyse:

  • Klasse: SchĂŒler (Substantiv)
  • Attribute: name, klasse, alter (Eigenschaften)
  • Methoden: berechneNoten(), vorstellen() (Verben)
Schueler
- name: String
- klasse: String
- alter: int
+ berechneNoten(): double
+ vorstellen(): void

Komplexeres Beispiel mit Beziehungen

Aufgabentext:

"Eine Schule besteht aus mehreren Klassen. Jede Klasse hat mehrere SchĂŒler und genau einen Klassenlehrer. Ein Klassenlehrer ist ein Lehrer."

Analyse der Beziehungen:

  • Schule ◆—— Klasse (Komposition: "besteht aus")
  • Klasse ◇—— Schueler (Aggregation: "hat")
  • Klasse ——— Klassenlehrer (Assoziation: "hat genau einen")
  • Klassenlehrer ——△ Lehrer (Vererbung: "ist ein")

📋 Zusammenfassung: UML Grundlagen

Klassenstruktur:

  • Drei Bereiche: Klassenname | Attribute | Methoden
  • Sichtbarkeit: + (public), - (private), # (protected)
  • Statisch: unterstrichen

Beziehungen:

——— Assoziation "kennt"
◇——— Aggregation "hat" (schwach)
◆——— Komposition "besteht aus" (stark)
——△ Vererbung "ist ein"

Text zu UML:

Substantive → Klassen | Eigenschaften → Attribute | Verben → Methoden