Uml Class Diagram Cheat Sheet

Kennst du das Gefühl, wenn du vor einem Berg an Code stehst und absolut keine Ahnung hast, wo du anfangen sollst? Oder wenn du versuchst, einem anderen Teammitglied dein komplexes Softwaresystem zu erklären, aber die Worte einfach nicht fließen wollen? Keine Sorge, damit bist du nicht allein! Hier kommt dein UML Klassendiagramm Cheat Sheet ins Spiel. Stell dir vor, du hättest eine Art Bauplan für Software, der auf einen Blick zeigt, wie alles zusammenhängt. Genau das ist ein UML Klassendiagramm!

Dieser Artikel ist speziell für Studierende und angehende Softwareentwickler gedacht, die die Grundlagen von UML Klassendiagrammen erlernen oder ihr Wissen auffrischen möchten. Wir werden gemeinsam die wichtigsten Elemente durchgehen, Beispiele anschauen und Tipps geben, damit du in Zukunft mühelos komplexe Softwaresysteme visualisieren und verstehen kannst. Also, krempel die Ärmel hoch, es wird spannend!

Was ist ein UML Klassendiagramm eigentlich?

Ein UML (Unified Modeling Language) Klassendiagramm ist eine Art grafische Darstellung der Struktur eines Softwaresystems. Es zeigt die Klassen, ihre Attribute (Daten) und Methoden (Funktionen) sowie die Beziehungen zwischen den Klassen. Denk an ein Haus: Die Klassen sind die einzelnen Räume (Küche, Schlafzimmer, Bad), die Attribute sind die Möbel und Gegenstände in den Räumen (Bett, Tisch, Stuhl) und die Methoden sind die Funktionen, die in den Räumen ausgeführt werden können (kochen, schlafen, duschen).

Must Read

Warum ist das Ganze überhaupt wichtig? Klassendiagramme helfen uns:

Komplexe Systeme zu verstehen: Sie vereinfachen die Darstellung komplexer Beziehungen und Strukturen.
Kommunikation zu verbessern: Sie dienen als gemeinsame Sprache zwischen Entwicklern, Designern und anderen Beteiligten.
Fehler frühzeitig zu erkennen: Sie ermöglichen es, Designfehler bereits in der Planungsphase zu identifizieren.
Code zu dokumentieren: Sie dienen als visuelle Dokumentation des Codes und erleichtern die Wartung und Weiterentwicklung.

Die Grundbausteine: Klassen, Attribute und Methoden

Klassen: Die Blaupausen für Objekte

Eine Klasse ist eine Vorlage oder ein Bauplan für Objekte. Sie definiert, welche Daten (Attribute) und Funktionen (Methoden) ein Objekt dieser Klasse haben wird. Stell dir eine Klasse als eine Art Keksform vor. Mit dieser Form kannst du viele Kekse (Objekte) herstellen, die alle die gleiche Form haben, aber unterschiedliche Füllungen (Attribute) haben können.

In einem Klassendiagramm wird eine Klasse durch ein Rechteck dargestellt. Dieses Rechteck ist in drei Bereiche unterteilt:

Name der Klasse: Steht im oberen Bereich des Rechtecks (z.B. `Kunde`, `Produkt`, `Bestellung`).
Attribute: Stehen im mittleren Bereich und beschreiben die Eigenschaften der Klasse (z.B. `name: String`, `preis: Double`, `bestelldatum: Date`).
Methoden: Stehen im unteren Bereich und beschreiben die Funktionen, die die Klasse ausführen kann (z.B. `bestellen()`, `bezahlen()`, `anzeigen()`).

Beispiel:


+---------------------+
|       Kunde        |
+---------------------+
| - name: String      |
| - adresse: String   |
| - kundennummer: int |
+---------------------+
| + bestellen()       |
| + bezahlen()        |
| + anzeigen()        |
+---------------------+

Erklärung:

`Kunde` ist der Name der Klasse.
`- name: String`, `- adresse: String`, `- kundennummer: int` sind die Attribute der Klasse. Das Minuszeichen (-) deutet auf eine private Sichtbarkeit hin (siehe Abschnitt Sichtbarkeit).
`+ bestellen()`, `+ bezahlen()`, `+ anzeigen()` sind die Methoden der Klasse. Das Pluszeichen (+) deutet auf eine public Sichtbarkeit hin (siehe Abschnitt Sichtbarkeit).

Attribute: Die Eigenschaften der Objekte

Attribute sind die Datenfelder, die ein Objekt einer Klasse beschreiben. Sie definieren, welche Informationen in einem Objekt gespeichert werden können. Denk an die Eigenschaften eines Autos: Farbe, Modell, Baujahr, etc. Das sind alles Attribute.

Die Syntax für ein Attribut in einem Klassendiagramm ist:


sichtbarkeit name: Datentyp

Beispiel:

Uml Class Diagram Relationships Cheat Sheet

`- name: String` (Name des Kunden als Text)
`# preis: Double` (Preis eines Produkts als Gleitkommazahl)
`+ bestelldatum: Date` (Datum der Bestellung)

Datentypen: Es gibt verschiedene Datentypen, die für Attribute verwendet werden können. Die häufigsten sind:

`String`: Text (z.B. "Hallo Welt")
`int`: Ganze Zahl (z.B. 123)
`Double`: Gleitkommazahl (z.B. 3.14)
`Boolean`: Wahrheitswert (true oder false)
`Date`: Datum (z.B. 2023-10-27)

Methoden: Die Aktionen der Objekte

Methoden sind die Funktionen, die ein Objekt einer Klasse ausführen kann. Sie definieren, was ein Objekt tun kann. Denk an die Funktionen eines Autos: fahren, bremsen, lenken. Das sind alles Methoden.

Die Syntax für eine Methode in einem Klassendiagramm ist:


sichtbarkeit name(parameter: Datentyp): Rückgabetyp

Beispiel:

`+ bestellen(): boolean` (Bestellung aufgeben, gibt `true` zurück, wenn erfolgreich, ansonsten `false`)
`# bezahlen(betrag: Double): void` (Bezahlung durchführen, nimmt den Betrag als Parameter entgegen, gibt nichts zurück)
`- anzeigen(): String` (Informationen anzeigen, gibt die Informationen als Text zurück)

Parameter: Methoden können Parameter entgegennehmen, die als Eingabe für die Funktion dienen. Im Beispiel `bezahlen(betrag: Double)` ist `betrag` der Parameter vom Typ `Double`.

Rückgabetyp: Methoden können einen Wert zurückgeben, nachdem sie ausgeführt wurden. Im Beispiel `bestellen(): boolean` gibt die Methode `bestellen()` einen Wert vom Typ `boolean` zurück.

Sichtbarkeit: Wer darf was sehen?

Die Sichtbarkeit bestimmt, welche anderen Klassen oder Objekte Zugriff auf ein Attribut oder eine Methode haben. Es gibt drei Haupttypen von Sichtbarkeit:

Public (+): Jeder kann darauf zugreifen.
Private (-): Nur die Klasse selbst kann darauf zugreifen.
Protected (#): Die Klasse selbst und ihre Unterklassen können darauf zugreifen.

Beispiel:

Ein Attribut `kundennummer` sollte in der Regel `private` sein, da es nicht von anderen Klassen direkt geändert werden sollte. Eine Methode `bestellen()` hingegen sollte `public` sein, damit Kunden eine Bestellung aufgeben können.

Die Beziehungen zwischen den Klassen: Beziehungen verstehen

Die Beziehungen zwischen den Klassen sind das Herzstück eines Klassendiagramms. Sie zeigen, wie die verschiedenen Klassen miteinander interagieren und zusammenarbeiten. Es gibt verschiedene Arten von Beziehungen:

Assoziation: Eine allgemeine Beziehung

Eine Assoziation ist die allgemeinste Form der Beziehung. Sie zeigt, dass zwei Klassen in irgendeiner Weise miteinander verbunden sind. Stell dir vor, ein Kunde kauft ein Produkt. Es gibt eine Assoziation zwischen der Klasse `Kunde` und der Klasse `Produkt`.

In einem Klassendiagramm wird eine Assoziation durch eine Linie zwischen den beiden Klassen dargestellt. Die Linie kann mit Pfeilen versehen sein, um die Richtung der Beziehung anzuzeigen.

Multiplizität: Die Multiplizität gibt an, wie viele Objekte einer Klasse mit Objekten einer anderen Klasse in Beziehung stehen können. Sie wird am Ende der Assoziationslinie angegeben.

`1`: Genau ein Objekt
`0..1`: Null oder ein Objekt
``: Null oder beliebig viele Objekte

`1..`: Mindestens ein Objekt
`n`: Genau n Objekte (z.B. 5)
`n..m`: Zwischen n und m Objekte (z.B. 2..5)

Beispiel:

Ein `Kunde` kann 0 oder beliebig viele `Bestellungen` aufgeben. Eine `Bestellung` gehört zu genau einem `Kunde`.


Kunde 1 ---- 0..* Bestellung

Aggregation: Eine "hat-ein"-Beziehung (Teil-Ganzes-Beziehung)

Eine Aggregation ist eine spezielle Form der Assoziation, die eine "hat-ein"-Beziehung darstellt. Sie zeigt, dass eine Klasse Teil einer anderen Klasse ist, aber die Teilklasse auch ohne die Ganzes-Klasse existieren kann. Denk an ein Auto und seine Reifen. Das Auto "hat Reifen", aber die Reifen können auch ohne das Auto existieren (z.B. als Ersatzreifen).

In einem Klassendiagramm wird eine Aggregation durch eine Linie mit einer leeren Raute am Ende der Ganzes-Klasse dargestellt.

Beispiel:

Eine `Klasse` hat `Studenten`. Die `Studenten` können aber auch ohne die `Klasse` existieren (z.B. wenn sie die Klasse wechseln).


Klasse <>---- Student

Komposition: Eine stärkere "hat-ein"-Beziehung

Eine Komposition ist eine noch stärkere Form der Assoziation, die ebenfalls eine "hat-ein"-Beziehung darstellt. Im Gegensatz zur Aggregation ist die Teilklasse untrennbar mit der Ganzes-Klasse verbunden und kann nicht ohne sie existieren. Denk an ein Gehirn und einen Körper. Das Gehirn ist Teil des Körpers und kann nicht ohne den Körper existieren (zumindest nicht in einem biologischen Kontext).

In einem Klassendiagramm wird eine Komposition durch eine Linie mit einer gefüllten Raute am Ende der Ganzes-Klasse dargestellt.

Beispiel:

Ein `Haus` hat `Zimmer`. Die `Zimmer` können nicht ohne das `Haus` existieren.


Haus ◆---- Zimmer

Generalisierung (Vererbung): Die "ist-ein"-Beziehung

Eine Generalisierung (auch Vererbung genannt) ist eine Beziehung, die eine "ist-ein"-Beziehung darstellt. Sie zeigt, dass eine Klasse (die Unterklasse) eine spezifischere Version einer anderen Klasse (der Oberklasse) ist und alle Attribute und Methoden der Oberklasse erbt. Denk an ein `Auto` und ein `Elektroauto`. Ein `Elektroauto` ist ein `Auto` und erbt alle Eigenschaften eines `Autos` (z.B. Räder, Lenkrad), hat aber auch spezifische Eigenschaften (z.B. Batterie, Elektromotor).

In einem Klassendiagramm wird eine Generalisierung durch eine Linie mit einem leeren Dreieck am Ende der Oberklasse dargestellt.

Beispiel:

`Hund` und `Katze` sind beides `Tier`e und erben alle Eigenschaften eines `Tier`s (z.B. Name, Alter).


Tier <|---- Hund
Tier <|---- Katze

Realisation (Implementierung): Die "implementiert"-Beziehung

Eine Realisation (auch Implementierung genannt) ist eine Beziehung zwischen einer Klasse und einem Interface. Sie zeigt, dass die Klasse das Interface implementiert, d.h. alle Methoden des Interfaces bereitstellt. Ein Interface definiert nur die Signatur der Methoden, nicht deren Implementierung. Die Klasse muss die Implementierung selbst bereitstellen.

In einem Klassendiagramm wird eine Realisation durch eine gestrichelte Linie mit einem leeren Dreieck am Ende des Interfaces dargestellt.

Beispiel:

Ein `Drucker` implementiert das Interface `Druckbar`. Das Interface `Druckbar` definiert die Methode `drucken()`. Der `Drucker` muss die Methode `drucken()` implementieren.


Druckbar ..|---- Drucker

Ein praktisches Beispiel: Eine Online-Shop-Anwendung

Um das Ganze etwas greifbarer zu machen, schauen wir uns ein Beispiel für eine Online-Shop-Anwendung an. Hier ist ein vereinfachtes Klassendiagramm:


+---------------------+       1      0..*      +---------------------+
|       Kunde        |-------------------------|      Bestellung     |
+---------------------+                       +---------------------+
| - name: String      |                       | - bestelldatum: Date|
| - adresse: String   |                       | - gesamtpreis: Double|
| - kundennummer: int |                       +---------------------+
+---------------------+                       | + hinzufuegenProdukt(produkt: Produkt) |
| + bestellen()       |                       | + berechneGesamtpreis()                  |
| + bezahlen()        |                       +---------------------+
| + anzeigen()        |
+---------------------+
     ^
     | 1..*
     |
+---------------------+       1      1..*      +---------------------+
|      Produkt       |-------------------------|   BestellPosition   |
+---------------------+                       +---------------------+
| - name: String      |                       | - menge: int        |
| - preis: Double     |                       | - produkt: Produkt  |
| - produktnummer: int|                       +---------------------+
+---------------------+
| + anzeigen()        |
+---------------------+

Erklärung:

Ein `Kunde` kann 0 oder beliebig viele `Bestellungen` aufgeben (Assoziation mit Multiplizität 0..).

Eine `Bestellung` gehört zu genau einem `Kunde` (Assoziation mit Multiplizität 1).

Eine `Bestellung` besteht aus mindestens einem `Produkt` (Assoziation über die Klasse `BestellPosition` mit Multiplizität 1..).
Ein `Produkt` kann in beliebig vielen `BestellPosition`en vorkommen (Assoziation mit Multiplizität 1..*).

Tipps und Tricks für die Erstellung von Klassendiagrammen

Beginne mit den wichtigsten Klassen: Identifiziere zuerst die Hauptakteure in deinem System.
Halte es einfach: Vermeide unnötige Komplexität. Konzentriere dich auf die wesentlichen Beziehungen und Attribute.
Verwende sprechende Namen: Wähle Namen, die die Bedeutung der Klassen, Attribute und Methoden klar widerspiegeln.
Verwende ein geeignetes Tool: Es gibt viele UML-Tools, die dir bei der Erstellung von Klassendiagrammen helfen können (z.B. Lucidchart, draw.io, Visual Paradigm).
Lass dich inspirieren: Schau dir Beispiele von Klassendiagrammen für ähnliche Systeme an.
Iteriere: Klassendiagramme sind selten perfekt beim ersten Versuch. Überarbeite und verbessere sie kontinuierlich.
Nutze Farben und Symbole: Um die Lesbarkeit zu verbessern, kannst du Farben und Symbole verwenden, um verschiedene Arten von Klassen und Beziehungen hervorzuheben.
Dokumentiere deine Entscheidungen: Warum hast du bestimmte Beziehungen oder Attribute gewählt? Dokumentiere deine Entscheidungen, damit andere (und du selbst später) sie verstehen können.

Fazit: Werde zum UML-Meister!

UML Klassendiagramme sind ein mächtiges Werkzeug für die Softwareentwicklung. Sie helfen uns, komplexe Systeme zu verstehen, die Kommunikation zu verbessern und Fehler frühzeitig zu erkennen. Mit diesem UML Klassendiagramm Cheat Sheet hast du das Rüstzeug, um deine eigenen Klassendiagramme zu erstellen und zu verstehen. Also, probier es aus, übe und werde zum UML-Meister! Denk daran: Übung macht den Meister! Je mehr du mit Klassendiagrammen arbeitest, desto besser wirst du sie verstehen und desto mehr wirst du von ihnen profitieren. Viel Erfolg!

Denke daran, dass dieses Cheat Sheet nur eine Einführung ist. Es gibt noch viele weitere Aspekte von UML Klassendiagrammen zu entdecken. Aber mit diesem Fundament bist du bestens gerüstet, um tiefer in die Materie einzutauchen und deine Softwareentwicklungsprojekte auf das nächste Level zu heben. Also, leg los und gestalte die Zukunft der Software!