UML-Klassendiagramm
Ein UML-Klassendiagramm zeigt die Struktur von Klassen in einem Programm. Es ist wie ein Bauplan für objektorientierte Software.
Mit einem UML-Klassendiagramm siehst du, welche Klassen es gibt, was sie können und wie sie zusammenhängen.
I. Aufbau eines Klassendiagramms
So ist eine Klasse im Diagramm aufgebaut.
Syntax
Eine Klasse besteht aus drei Teilen:
┌─────────────────────┐
│ Klassenname │ ← 1. Name (großgeschrieben!)
├─────────────────────┤
│ - attribut: Typ │ ← 2. Attribute (Eigenschaften)
│ - weiteres: Typ │
├─────────────────────┤
│ + methode(): Typ │ ← 3. Methoden (Funktionen)
│ + andere(): void │
└─────────────────────┘
Zugriffsmodifikatoren
Zeigen, wer auf Attribute und Methoden zugreifen darf.
Die vier Zugriffsmodifikatoren:
| Symbol | Name | Bedeutung |
|---|---|---|
| + | Public | Alle können darauf zugreifen |
| - | Private | Nur die Klasse selbst |
| # | Protected | Klasse + Kindklassen |
| ~ | Package-Private | Nur im gleichen Paket |
Beispiel:
┌─────────────────────┐
│ Person │
├─────────────────────┤
│ - name: String │ ← Private (nur intern)
│ + alter: int │ ← Public (alle sehen es)
│ # adresse: String │ ← Protected (Kindklassen)
├─────────────────────┤
│ + getName(): String │ ← Public-Methode
│ - validate(): bool │ ← Private-Methode
└─────────────────────┘
Datentypen und Rückgabewerte
Bei Attributen:
- attributName: Datentyp
Beispiel: - alter: int
Bei Methoden:
+ methodenName(parameter: Typ): Rückgabetyp
Beispiel: + berechneAlter(geburtsjahr: int): int
Wenn Methode nichts zurückgibt:
+ methodenName(): void
Beispiel: + anzeigen(): void
- Klassenname: Großgeschrieben (z.B.
Auto,Kunde) - Attribute: Kleingeschrieben (z.B.
name,alter) - Methoden: Kleingeschrieben (z.B.
getName(),berechnen()) - Datentypen: Nach Doppelpunkt (z.B.
: String,: int)
II. Praxisbeispiel: Von Code zum Diagramm
So sieht eine echte Klasse in Code und als Diagramm aus.
Java-Code:
public class Auto {
// Attribute (Eigenschaften) des Autos
private String marke;
private String modell;
private int baujahr;
private boolean istAn;
// Konstruktor zur Initialisierung eines Autos
public Auto(String marke, String modell, int baujahr) {
this.marke = marke;
this.modell = modell;
this.baujahr = baujahr;
this.istAn = false;
}
// Methode zum Starten des Autos
public void starten() {
if (!istAn) {
istAn = true;
System.out.println(marke + " " + modell + " ist gestartet.");
} else {
System.out.println(marke + " " + modell + " läuft bereits.");
}
}
// Methode zum Ausschalten des Autos
public void ausschalten() {
if (istAn) {
istAn = false;
System.out.println(marke + " " + modell + " wurde ausgeschaltet.");
} else {
System.out.println(marke + " " + modell + " ist bereits aus.");
}
}
// Getter-Methode
public int getBaujahr() {
return baujahr;
}
// Methode zur Ausgabe von Informationen
public void anzeigenInfo() {
System.out.println("Marke: " + marke + ", Modell: " + modell + ", Baujahr: " + baujahr);
}
}
Diese Klasse können wir in einem UML-Klassendiagramm darstellen, um eine bessere Übersicht zu haben.
Als UML-Klassendiagramm:
Vom Code ins Diagramm:
Java-Code UML-Diagramm
─────────── ─────────────
class Auto → ┌──────────────┐
│ Auto │
├──────────────┤
private String → │ - marke: String
private int → │ - baujahr: int
├──────────────┤
public void → │ + starten(): void
public int → │ + getBaujahr(): int
└──────────────┘
III. Klassen verbinden
Klassen stehen nicht alleine - sie haben Beziehungen zueinander.
In UML gibt es verschiedene Arten von Verbindungen:
- Assoziation - "kennt" Beziehung
- Vererbung - "ist ein" Beziehung
- Aggregation - "hat ein" Beziehung (lose)
- Komposition - "hat ein" Beziehung (fest)
Assoziation
Eine einfache Verbindung zwischen Klassen.
ASCII-Darstellung:
┌──────────┐ ┌──────────┐
│ Kunde │───────────│ Bestellung│
└──────────┘ └──────────┘
"Kunde erstellt Bestellung"
Vererbung
Eine Klasse erbt von einer anderen.
ASCII-Darstellung:
┌──────────┐
│ Tier │
└────△─────┘
│ (Dreieck zeigt zum Elternteil)
│
┌─────┴─────┐
│ │
┌───┴───┐ ┌───┴───┐
│ Hund │ │ Katze │
└───────┘ └───────┘
"Hund ist ein Tier"
"Katze ist ein Tier"
Aggregation
Eine Klasse "hat" eine andere (lose Verbindung).
ASCII-Darstellung:
┌──────────┐ ┌──────────┐
│ Kurs │◇───────│ Student │
└──────────┘ └──────────┘
(Leere Raute)
"Kurs hat Studenten"
(Studenten können ohne Kurs existieren)
Komposition
Eine Klasse "besitzt" eine andere (feste Verbindung).
ASCII-Darstellung:
┌──────────┐ ┌──────────┐
│ Haus │◆───────│ Raum │
└──────────┘ └──────────┘
(Gefüllte Raute)
"Haus besteht aus Räumen"
(Räume können nicht ohne Haus existieren)
IV. Multiplizität (Kardinalität)
Wie viele Objekte können verbunden sein?
Notation:
┌──────────┐ 1 0..* ┌──────────┐
│ Kunde │───────────────│ Bestellung│
└──────────┘ └──────────┘
│ │
└→ 1 Kunde └→ 0 oder mehr Bestellungen
Häufige Multiplizitäten:
| Notation | Bedeutung |
|---|---|
| 1 | Genau eins |
| 0..1 | Null oder eins |
| * | Beliebig viele (0 bis ∞) |
| 0..* | Null oder mehr |
| 1..* | Eins oder mehr |
| n | Genau n (z.B. 5) |
| n..m | Zwischen n und m (z.B. 2..5) |
1:1 Beziehung:
┌──────────┐ 1 1 ┌──────────┐
│ Person │────────────│ Ausweis │
└──────────┘ └──────────┘
"Jede Person hat genau einen Ausweis"
1:n Beziehung:
┌──────────┐ 1 0..* ┌──────────┐
│ Lehrer │─────────────│ Schüler │
└──────────┘ └──────────┘
"Ein Lehrer hat viele Schüler"
n:m Beziehung:
┌──────────┐ * * ┌──────────┐
│ Student │────────────│ Kurs │
└──────────┘ └──────────┘
"Viele Studenten in vielen Kursen"
V. Abstrakte Klassen
Klassen, von denen man keine Objekte erstellen kann.
Darstellung:
- Klassenname kursiv schreiben
- Oder:
<<abstract>>über den Namen
┌─────────────────┐
│ <<abstract>> │
│ Tier │ oder ┌──────────┐
├─────────────────┤ │ *Tier* │
│ + bewegen() │ └──────────┘
└─────────────────┘
Eigenschaften:
- Kann nicht instanziiert werden
- Dient als Vorlage für Kindklassen
- Kann abstrakte Methoden haben
VI. Prüfungswissen
Das musst du für die IHK-Prüfung können.
Aufbau kennen:
- Drei Bereiche: Name, Attribute, Methoden
- Zugriffsmodifikatoren: +, -, #, ~
- Datentypen nach Doppelpunkt
Beziehungen zeichnen können:
- Assoziation (einfache Linie)
- Vererbung (Dreieck zum Elternteil)
- Aggregation (leere Raute)
- Komposition (gefüllte Raute)
Multiplizität verstehen:
- 1, , 0..1, 1.., 0..*
- An beide Enden der Linie schreiben
Von Code ins Diagramm:
- Java-Klasse in UML umwandeln können
- Attribute und Methoden richtig eintragen
- Beziehungen erkennen
Frage: "Erstellen Sie ein Klassendiagramm für ein Bibliothekssystem mit den Klassen Buch, Autor und Ausleihe."
Antwort:
┌────────────────┐ 1 1..* ┌──────────────┐
│ Autor │────────────────│ Buch │
├────────────────┤ ├──────────────┤
│ - name: String │ │ - titel: String│
│ - id: int │ │ - isbn: String│
├────────────────┤ ├──────────────┤
│ + getName() │ │ + ausleihen()│
└────────────────┘ └──────┬───────┘
│
1 │ 0..*
│
┌─────┴──────┐
│ Ausleihe │
├────────────┤
│ - datum │
│ - kunde │
└────────────┘
Erklärung:
- Ein Autor schreibt 1 oder mehr Bücher (1:*)
- Ein Buch kann 0 oder mehr Ausleihen haben (1:0..*)
VII. Häufige Fehler
Das solltest du vermeiden.
1. Falsche Zugriffsmodifikatoren:
❌ FALSCH:
public name: String
✅ RICHTIG:
+ name: String
2. Klassenname klein geschrieben:
❌ FALSCH:
┌──────────┐
│ auto │
✅ RICHTIG:
┌──────────┐
│ Auto │
3. Vererbungspfeil falsch:
❌ FALSCH:
Hund ──→ Tier
✅ RICHTIG:
Hund ──△ Tier
(Dreieck zeigt zum Elternteil!)
4. Multiplizität vergessen:
❌ FALSCH:
Kunde ───── Bestellung
✅ RICHTIG:
Kunde ──1:*── Bestellung
VIII. Zusammenfassung
Klassendiagramm zeigt:
- Aufbau von Klassen (Attribute + Methoden)
- Beziehungen zwischen Klassen
- Sichtbarkeit (public, private, protected)
- Multiplizität (wie viele?)
Wichtigste Beziehungen:
- Assoziation: ─────
- Vererbung: ──△
- Aggregation: ◇────
- Komposition: ◆────
Für die Prüfung:
- Symbole kennen und anwenden
- Diagramm aus Text/Code erstellen
- Beziehungen richtig zeichnen
- Multiplizität angeben