Klassendiagramme

Reihenfolge

Die Reihenfolge in der die Inhalte des Klassendiagramms angegeben werden ist fest definiert: Zuerst die Einbindungen (Imports), dann die Klassifizierer, danach die Verbindungen und zum Schluss Pakete. Auch innerhalb der Pakete muss diese Reihenfolge eingehalten werden.

Ein Block im Klassendiagramm wird immer durch geschweifte Klammern gesetzt. Dabei wird empfohlen, die öffnende Klammer in die gleiche Zeile wie die Definition des Blockkopfes (Klasse-, Interface-, Paket-Definition) zu setzen und die schließende Klammer in eine eigene Zeile.

Klassendefinition

Eine Klasse wird mit dem Schlüsselwort class und einer ID (dem Bezeichner) definiert. Diese ID darf keine Leerzeichen enthalten außer der Klassenname wird in Anführungszeichen gesetzt. Für solche Klassennamen in Anführungszeichen kann mittels des Schlüsselworts as ein Alias vergeben werden. Das Alias wird dazu direkt hinter das Keyword as gesetzt.

class Lang as "LangerKlassenname"

Sichtbarkeiten

Um die Sichtbarkeit der Klasse zu definieren wird der entsprechende Operand (public, private, protected) oder das UML-typische Kürzel (+,-,#,~) vor den Operand class gestellt.

public class MeineKlasse

Dabei ist zu beachten, dass die Sichtbarkeit package nur als Tilde-Zeichen dargestellt werden kann. Wird keine Sichtbarkeit angegeben wird dies als public gewertet.

Soll die Klasse als abstract definiert werden, wird das Schlüsselwort abstract vor class gesetzt, jedoch nach dem Sichtbarkeits Schlüsselwort falls dieses definiert wurde.

private abstract class MeineKlasse

Methoden und Attribute

Attribute und Methoden werden als Block in geschweiften Klammern hinter der Klassendefinition angegeben. Dabei wird zuerst der Name angegeben, gefolgt vom einem Doppelpunkt und dem Attributtyp.

class MeineKlasse{
    attributname: attributtyp
}

Unterstützte Typen sind: string, int, double, boolean, char, byte, short, long, float.

Attribute können ebenfalls Sichtbarkeiten haben oder static oder final sein, dies wird mit den jeweiligen Schlüsselwörtern vor dem Attributnamen definiert.

final pi:float

Parameterübergabe

Mehrere Parameter werden mittels eines Kommas getrennt. Eine Methode ohne Parameter muss dennoc 2 Klammern definiert haben, um die ID als Methode zu deklarieren. Der Rückgabewert einer Methode wird mittels eines Doppelpunkts hinter die Methode gesetzt.

methode():rueckgabetyp
methodenname(parametername:parametertyp, param:string)

Die Sichtbarkeit und die Schlüsselwörter abstract, final oder static können ebenfalls vor dem Methodennamen gesetzt werden.

public static main(argument: String)

Interfaces

Interfaces werden genau wie Klassen definiert, nur mit dem Schlüsselwort interface. Attribute und Methoden werden wie bei Klassen deklariert, das Schlüsselwort abstract ist bei Interfaces nicht gültig.

interface Tier

Pakete

Pakete werden mit dem Schlüsselwort package und einer eindeutigen ID definiert. Paketnamen können keine Alias besitzen und benötigen immer einen Block, welcher durch geschweifte Klammern gekennzeichnet wird.

package MeinPaketname {
}

Pakete können Elemente aus anderen Paketen mithilfe des Schlüsselworts import und der entsprechenden Referenz ID beschreiben.

package Paket1{
    Klasse1
}
package Paket2{
    import Paket1
    class Klasse2
}

Pakete können beliebig geschachtelt werden. Soll eine Klasse aus einem Unterpaket genutzt werden, muss dies über die vollständige Referenz erfolgen.

package Paket{
    class Test
    asc hat (Test, Unterpaket.Unterklasse)
    package Unterpaket {
        class Unterklasse
    }
}

Assoziationen

Eine einfache Assoziation wird durch das Schlüsselwort asc eingeleitet.

"Einfache Assoziation zwischen Klassen A und B"
    class A
    class B
    asc name(A,B)

Dabei folgt die Richtung der Assoziation immer der Reihenfolge der Operanden.

asc hat(Zoo,Tiger)
asc lebtIn(Tiger,Zoo)

Die Ausnahmen bilden bidirektionale Assoziationen welche mit dem Schlüsselwort bi eingeleitet wird.

@start-clsd "Bidirektionale Assoziation zw Klassen A und B"
    class A
    class B
    bi asc name (A,B)
    @end-clsd

Kompositionen und Aggregationen

Teil-eines-Ganzen Verbindungen – also Komposition und Aggregationen – werden über die Schlüsselwörter com und agg eingeleitet. Die Klasse mit dem Kompositions-, oder Aggregationsende wird zuerst genannt.

com bestehtAus(Zoo,Gehege)
agg besitzt(Zoo,Gehege)

Vererbung

Die Vererbung zwischen Klassen wird durch das Schlüsselwort isa eingeleitet, gefolgt von den Operanden. Die Vererbung ist die einzige Ausnahme bei der kein Bezeichner angegeben wird.

isa(Tier,Tiger)

Rollen und Kardinaltitäten

Assoziationen können durch Rollen oder Kardinalitäten (auch Multiplizitäten genannt) genauer spezifiziert werden. Dazu werden die Eigenschaften hinter den Operanden in eckigen Klammern aufgeführt. Die Reihenfolge der Operanden bestimmt dabei die Zuordnung der Attribute zu den Operanden. Rollen werden mit dem Schlüsselwort role, Kardinalitäten mit dem Schlüsselwort card eingeleitet.

asc pflege (tier, tierarzt) role[Patient, Arzt]

Soll für einen Operanden kein Attributwert angegeben werden, wird dies durch einen Unterstrich _ symbolisiert.

asc pflege (tier, tierarzt) role[patient,_]

Die Beschreibung von Kardinalitäten ist analog zu Rollen, jedoch werden diese nicht mit Komma sondern mit einem Doppelpunkt getrennt. Die default Kardinalität ist 0..1

asc pflege (tier, tierarzt) card[*:0..1]

Rollen und Kardinalitäten können auch kombiniert werden, indem diese Attribute hintereinander verkettet werden.

asc pflege (tier, tierarzt) role[Patient, Arzt] card[*:0..1]

Realisation/Implementation

Die Implementierung eines Interfaces wird mit dem Schlüsselwort impl eingeführt. Die Klasse die das Interface implementiert wird zuerst genannt, gefolgt von dem Interface das sie implementiert.

asc has (Schimpanse, Schaukel) card[1:1] role[Besitzer, _]

asc Bezeichner (A,B,C) role[RolleA, RolleB, RolleC] card[KardA:KardB:KardC]

class A note["Notiz an einer Klasse"]
interface A note["Notiz an einer Interface"]

class A {
    name: string
    note ["Notiz für die Klasse"]
}

Beispiele

@start-clsd "class"

rootPackage RootElement

class Animal {
	+ name : string
}

- class Giraffe
- class Zebra
class Zoo
class Zookeeper {
	- feed ( animal : Animal )
}

isa (Giraffe, Animal)
isa (Zebra, Animal)
asc employed (Zookeeper, Zoo) card [1..* : 1..1]
asc inhabitant (Animal, Zoo) card [0..100 : 1..1]

@end-clsd