@startuml
abstract abstract
abstract class "abstract class"
annotation annotation
circle circle
() circle_short_form
class class
diamond diamond
<> diamond_short_form
entity entity
enum enum
interface interface
@enduml
Beziehungen zwischen Klassen
Beziehungen zwischen Klassen werden mit den folgenden Symbolen gekennzeichnet:
Type
Symbol
Drawing
Extension
<|--
Composition
*--
Aggregation
o--
Es ist möglich -- durch .. zu ersetzen, um eine gepunktete Linie zu erhalten. Wenn man diese Regeln kennt, ist es möglich, die folgenden Zeichnungen zu zeichnen:
Beziehungen können beschriftet werden, durch das Anhängen eines Doppelpunktes : gefolgt von dem Beschriftungstext. Um Kardinalität anzuzeigen, verwendet man doppelte Anführungszeichen "" auf jeder Seite der Beziehung.
Um zu zeigen, in welche Richtung die Beziehung wirkt, können an die Beschriftung zusätzliche Pfeilspitzen angehängt werden, indem man vor die Beschriftung < oder nach der Beschriftung > verwendet.
@startuml
class Car
Driver - Car : drives >
Car *- Wheel : have 4 >
Car -- Person : < owns
@enduml
Methoden hinzufügen
Um Feldern und Methoden zu einer Klasse hinzuzufügen, wird der Doppelpunkt : gefolgt von dem Namen des Feldes oder der Methode verwendet. Das System erkennt anhand der Klammern, ob es sich um eine Methode oder um ein Feld handelt.
Sie können statische oder abstrakte methoden und statische Attribute durch benutzen des {static} oder {abstract} Modifikators definieren. Diese Modifikatoren können am Anfang oder am Ende der Zeile benutzt werden. Es kann auch {classifier} statt {static} benutzt werden.
@startuml
class Dummy {
{static} String id
{abstract} void methods()
}
@enduml
Der Klassenrumpf für Fortgeschrittene
Standardmäßig werden die Methoden und Felder im Klassenrumpf automatisch von PlantUML gruppiert. Mit Hilfe von Trennzeichen können Felder und Methoden aber auch selber geordnet werden. Folgende Trennzeichen sind möglich: -- (einfache durchzogene Linie), .. (einfache unterbrochene Linie), == (doppelte durchzogene Linie, __ (dicke durchzogene Linie). Es können auch Titel innerhalb des Trennzeichen angegeben werden:
@startuml
class Foo1 {
You can use
several lines
..
as you want
and group
==
things together.
__
You can have as many groups
as you want
--
End of class
}
class User {
.. Simple Getter ..
+ getName()
+ getAddress()
.. Some setter ..
+ setName()
__ private data __
int age
-- encrypted --
String password
}
@enduml
Notizen und Stereotypen
Stereotypen werden mit dem Schlüsselwort class oder mit den Symbolen << (doppelte spitze Klammer links) und >> (doppelte spitze Klammer rechts) definiert. Zwischen den Klammern wird der Name des Stereotyps angegeben. Mit den note left of , note right of, note top of , note bottom of Schlüsselwörtern kann man Notizen und ihre Position festlegen. Eine Notiz zur zuletzt definierten Klasse wird mit den Schlüsselwörtern note left, note right,note top, note bottom hinzugefügt. Eine Notiz kann aber auch nur mit dem note Schlüsselwort erstellt werden und dann mit dem .. Symbol den Klassen zugeordnet werden.
@startuml
class Object << general >>
Object <|--- ArrayList
note top of Object : In java, every class\nextends this one.
note "This is a floating note" as N1
note "This note is connected\nto several objects." as N2
Object .. N2
N2 .. ArrayList
class Foo
note left: On last defined class
@enduml
Mehr zu Notizen
Es ist auch möglich einige HTML Tags wie:
<b>
<u>
<i>
<s>, <del>, <strike>
<font color="#AAAAAA"> or <font color="colorName">
<color:#AAAAAA> or <color:colorName>
<size:nn> to change font size
<img src="file"> or <img:file>: the file must be accessible by the filesystem
Es ist auch möglich eine Notiz über mehrere Zeilen zu erstellen. Eine Notiz bezogen auf die letzte definierte Klasse kann mit note left, note right, note top oder note bottom erstellt werden.
@startuml
class Foo
note left: On last defined class
note top of Object
In java, <size:18>every</size> <u>class</u>
<b>extends</b>
<i>this</i> one.
end note
note as N1
This note is <u>also</u>
<b><color:royalBlue>on several</color>
<s>words</s> lines
And this is hosted by <img:sourceforge.jpg>
end note
@enduml
WARNING
This translation need to be updated.
WARNING
Note on field (field, attribute, member) or method
It is possible to add a note on field (field, attribut, member) or on method.
Note on field or method
@startuml
class A {
{static} int counter
+void {abstract} start(int timeout)
}
note right of A::counter
This member is annotated
end note
note right of A::start
This method is now explained in a UML note
end note
@enduml
Note on method with the same name
@startuml
class A {
{static} int counter
+void {abstract} start(int timeoutms)
+void {abstract} start(Duration timeout)
}
note left of A::counter
This member is annotated
end note
note right of A::"start(int timeoutms)"
This method with int
end note
note right of A::"start(Duration timeout)"
This method with Duration
end note
@enduml
Eine Notiz zu einer Beziehung kann direkt nach der Beziehungsdefinition erfolgen: note on link. Zur relativen Positionierung der Notiz können die Schlüsselwörter note left on link, note right on link, note top on link, note bottom on link verwendet werden.
@startuml
class Dummy
Dummy --> Foo : A link
note on link #red: note that is red
Dummy --> Foo2 : Another link
note right on link #blue
this is my note on right link
and in blue
end note
@enduml
Abstrakte Klassen und Interfaces
Eine abstrakte Klasse lässt sich über das abstract oder das abstract class Schlüsselwort definieren. Die Klasse wird dann kursiv gedruckt. Man kann auch die interface, annotation und enum Schlüsselwörter verwenden.
@startuml
abstract class AbstractList
abstract AbstractCollection
interface List
interface Collection
List <|-- AbstractList
Collection <|-- AbstractCollection
Collection <|- List
AbstractCollection <|- AbstractList
AbstractList <|-- ArrayList
class ArrayList {
Object[] elementData
size()
}
enum TimeUnit {
DAYS
HOURS
MINUTES
}
annotation SuppressWarnings
@enduml
*[Ref. 'Annotation with members' [Issue#458](https://github.com/plantuml/plantuml/issues/458)]*
WARNING
This translation need to be updated.
WARNING
Verwendung von Sonderzeichen
Wenn sie in dem Name Ihrer Klasse (oder des Enums, oder der Schnittstelle) Zeichen verwenden wollen, dann gibt es die folgenden Möglichkeiten:
Verwenden Sie das as Schlüsselwort in der Definition
Schließen Sie den Namen in Hochommas "" ein
@startuml
class "This is my class" as class1
class class2 as "It works this way too"
class2 *-- "foo/dummy" : use
@enduml
Verstecken von Attributen, Methoden ...
Die Anzeige einer Klasse kann über das hide/show Kommando parametrisiert werden. Der Basisbefehl ist hide empty members. Mit diesem Befehl werden leere Atribute und Methoden ausgeblendet. Anstelle von empty members kann man auch die folgenden Befehle verwenden:
empty fields oderr empty attributes für leere Felder,
empty methods für leere Methoden,
fields oder attributes um Felder auszublenden, auch wenn diese definiert sind,
methods um Methoden auszublenden, auch wenn diese definiert sind,
members um Methoden und Felder auszublenden, auch wenn diese definiert sind,
circle um einen in einen Kreis eingeschlossenen Buchstaben vor dem Klassennamen anzuzeigen,
stereotype um einen Stereotypen anzuzeigen.
Nach dem hide oder dem show Schlüsselwort kann man auch noch die folgenden Befehle anfügen:
class für alle Klassen,
interface für alle Schnittstellen,
enum für alle Enums,
<<foo1>> für alle Klassen, die mit dem Stereotyp foo1 ausgezeichnet sind,
einen namen einer existierenden Klasse.
Es lassen sich mehrere show/hide Befehle verketten, um Regeln und ausnahmen festzulegen.
@startuml
class Dummy1 {
+myMethods()
}
class Dummy2 {
+hiddenMethod()
}
class Dummy3 <<Serializable>> {
String name
}
hide members
hide <<Serializable>> circle
show Dummy1 methods
show <<Serializable>> fields
@enduml
Verstecken von Klassen
Mit den show/hide Befehlen können Klassen versteckt werden. Dies kann hilfreich sein, wenn man eine große !included Datei verwendet und dann einige Klassen nach dem einbinden der Datei verstecken möchte.
@startuml
class Foo1
class Foo2
Foo2 *-- Foo1
hide Foo2
@enduml
WARNING
This translation need to be updated.
WARNING
Remove classes
You can also use the remove commands to remove classes. This may be useful if you define a large !included file, and if you want to remove some classes after file inclusion.
@startuml
class Foo1
class Foo2
Foo2 *-- Foo1
remove Foo2
@enduml
Hide or Remove unlinked class
By default, all classes are displayed:
@startuml
class C1
class C2
class C3
C1 -- C2
@enduml
But you can:
hide @unlinked classes:
@startuml
class C1
class C2
class C3
C1 -- C2
hide @unlinked
@enduml
or remove @unlinked classes:
@startuml
class C1
class C2
class C3
C1 -- C2
remove @unlinked
@enduml
Mit spitzen Klammern ( < und >) kann die Verwendung von Generics dargestellt werden.
@startuml
class Foo<? extends Element> {
int size()
}
Foo *- Element
@enduml
Man kann diese Darstellung mittels des Befehls skinparam genericDisplay old ausschalten.
Besondere Hervorhebungen
Normalerweise werden Klassen, Schnittstellen, Enums und abstrakte Klassen mit einem hervorgehobenen Buchstaben gekennzeichnet (C, I, E or A). Es ist aber auch möglich eine eigene Hervorhebung zu erstellen wenn man einen Stereotyp definiert. Das wird durch hinzufügen eines einzelnen Buchstabens und einer Farbe so wie im folgenden Beispiel erreicht:
@startuml
class System << (S,#FF7700) Singleton >>
class Date << (D,orchid) >>
@enduml
Pakete
Pakete können über das package Schlüsselwort definiert werden. Auf Wunsch kann außerdem die die Hintergrundfarbe für das Paket festgelegt werden. Dies kann durch den Farbnamen oder den HTML Code geschehen. Es ist möglich, Pakete ineinander zu schachteln.
Es stehen verschiedene Arten von Paketen zur Verfügung. Welches Paket zur Verwendung kommen soll, kann mit dem Befehl skinparam packageStyle festgelegt werden. Alternativ kann ein Stereotyp in der Paketdefinition verwendet werden.
@startuml
scale 750 width
package foo1 <<Node>> {
class Class1
}
package foo2 <<Rectangle>> {
class Class2
}
package foo3 <<Folder>> {
class Class3
}
package foo4 <<Frame>> {
class Class4
}
package foo5 <<Cloud>> {
class Class5
}
package foo6 <<Database>> {
class Class6
}
@enduml
Außerdem ist es möglich, Abhängigkeiten zwischen Paketen zu definieren, wie dies im folgenden Beispiel gezeigt wird:
In Paketen ist der Name einer Klasse der eindeutige Bezeichner der Klasse. Das bedeutet, das man nicht zwei Klassen mit dem gleichen Namen in unterschiedlichen Paketen haben kann. In diesem Fall sollte ein Namensraum anstelle eine Pakets verwendet werden. Man kann auf eine Klasse aus einem anderen Namensraum verweisen, in dem man den voll qualifizierten Namen der Klasse angibt. Klassen aus dem Standartnamensraum werden mit einem beginnenden Punkt gekennzeichnet. Beachten Sie, das ein Namensraum nicht explizit festgelegt werden muss: Eine vollqulifizierte Klasse verwendet automatisch den richtigen Namensraum.
@startuml
class BaseClass
namespace net.dummy #DDDDDD {
.BaseClass <|-- Person
Meeting o-- Person
.BaseClass <|- Meeting
}
namespace net.foo {
net.dummy.Person <|- Person
.BaseClass <|-- Person
net.dummy.Meeting o-- Person
}
BaseClass <|-- net.unused.Person
@enduml
Automatische Erzeugung eines Namensraums
Über folgenden Befehl kann ein anderes Trennzeichen (als der Punkt) definiert werden: set namespaceSeparator ???.
@startuml
set namespaceSeparator ::
class X1::X2::foo {
some info
}
@enduml
Die automatische Erzeugung eines Pakets kann mit set namespaceSeparator none deaktiviert werden.
@startuml
set namespaceSeparator none
class X1.X2.foo {
some info
}
@enduml
Lollipop Schnittstellen
Mit der folgenden Syntax kann man Schnittstellen von Klassen definieren:
bar ()- foo
bar ()-- foo
foo -() bar
@startuml
class foo
bar ()- foo
@enduml
Ändern der Pfeilrichtung
Normalerweise werden Beziehungen zwischen Klassen mit zwei Strichen -- definiert und die Klassen werden Vertikal angeordnet. Verwendet man nur einen Strich (oder Punkt), dann werden die Klassen horizontal angeordnet so wie im folgenden Beispiel zu sehen ist:
@startuml
Room o- Student
Room *-- Chair
@enduml
Man kann die Richtung auch durch das Umdrehen der Verbindung ändern:
@startuml
Student -o Room
Chair --* Room
@enduml
Außerdem ist es möglich, die Richtung der Pfeile durch Hinzufügen der left, right, up oder down Schlüsselwörter innerhalb der Pfeile zu verändern:
Die Länge der Pfeile kann verkürzt werden, in dem man nur den ersten Buchstaben für die Richtung verwendet (zum Beispiel, -d- anstelle von -down-) oder die ersten beiden Buchstaben (-do-) Bitte verwenden Sie diese Möglichkeit nur wenn es unbedingt sein muss: GraphViz liefert normalerweise recht gute Ergebnisse ohne das manuell eingegriffen werden muss.
Assoziationsklassen
Nach dem man eine Beziehung zwischen zwei Klassen definiert hat, kann man eine association class definieren. Hierzu ein Beispiel:
@startuml
class Student {
Name
}
Student "0..*" - "1..*" Course
(Student, Course) .. Enrollment
class Enrollment {
drop()
cancel()
}
@enduml
Die Richtung lässt ich aber auch ändern:
@startuml
class Student {
Name
}
Student "0..*" -- "1..*" Course
(Student, Course) . Enrollment
class Enrollment {
drop()
cancel()
}
@enduml
Association on same classe
@startuml
class Station {
+name: string
}
class StationCrossing {
+cost: TimeInterval
}
<> diamond
StationCrossing . diamond
diamond - "from 0..*" Station
diamond - "to 0..* " Station
@enduml
Mit der # Notation können individuelle Farben für Klassen oder Notizen definiert werden. Es kann entweder der Standardname der Farbe oder der RGB Code verwendet werden. Für den Hintergrund kann ebenfalls ein Farbverlauf verwendet werden: Zwei Farbnamen getrennt durch:
|,
/,
\,
oder -
abhängig von der Richtung des Verlaufs. So könnte dies zum Beispiel aussehen:
@startuml
skinparam backgroundcolor AntiqueWhite/Gold
skinparam classBackgroundColor Wheat|CornflowerBlue
class Foo #red-green
note left of Foo #blue\9932CC
this is my
note on this class
end note
package example #GreenYellow/LightGoldenRodYellow {
class Dummy
}
@enduml
WARNING
This translation need to be updated.
WARNING
Hilfe beim Layout
Manchmal ist das vorgegebene Layout nicht optimal. Sie können das together Schlüsselwort benutzen, um der Layout-Engine die Anweisung zu geben einige Klassen zu gruppieren (ähnlich einem package). Mit hidden Links kann man auch ein Layout erzwingen.
@startuml
class Bar1
class Bar2
together {
class Together1
class Together2
class Together3
}
Together1 - Together2
Together2 - Together3
Together2 -[hidden]--> Bar1
Bar1 -[hidden]> Bar2
@enduml
Große Dateien aufteilen
Manchmal erhält man sehr große Bilddateien.Mit dem page (hpages)x(vpages) Befehl kann das erzeugte Bildauf mehrere Dateien verteilt werden: Mit dem page (hpages)x(vpages) Befehl kann das erzeugte Bild auf mehrere Dateien aufgeteilt werden: hpages gibt die Anzahl von horizontalen Seiten an, und vpages gibt die Anzahl von vertikalen Seiten an. Die Verwendung von skinparam Definitionen, ermöglicht die Darstellung von Außenrahmen für mehrseitige Bilder. (Siehe nachfolgendes Beispiel)
@startuml
' Split into 4 pages
page 2x2
skinparam pageMargin 10
skinparam pageExternalColor gray
skinparam pageBorderColor black
class BaseClass
namespace net.dummy #DDDDDD {
.BaseClass <|-- Person
Meeting o-- Person
.BaseClass <|- Meeting
}
namespace net.foo {
net.dummy.Person <|- Person
.BaseClass <|-- Person
net.dummy.Meeting o-- Person
}
BaseClass <|-- net.unused.Person
@enduml
Extends and implements
It is also possible to use extends and implements keywords.
@startuml
class ArrayList implements List
class ArrayList extends AbstractList
@enduml
Bracketed relations (linking or arrow) style
Line style
It's also possible to have explicitly bold, dashed, dotted, hidden or plain relation, links or arrows:
without label
@startuml
title Bracketed line style without label
class foo
class bar
bar1 : [bold]
bar2 : [dashed]
bar3 : [dotted]
bar4 : [hidden]
bar5 : [plain]
foo --> bar
foo -[bold]-> bar1
foo -[dashed]-> bar2
foo -[dotted]-> bar3
foo -[hidden]-> bar4
foo -[plain]-> bar5
@enduml
with label
@startuml
title Bracketed line style with label
class foo
class bar
bar1 : [bold]
bar2 : [dashed]
bar3 : [dotted]
bar4 : [hidden]
bar5 : [plain]
foo --> bar : ∅
foo -[bold]-> bar1 : [bold]
foo -[dashed]-> bar2 : [dashed]
foo -[dotted]-> bar3 : [dotted]
foo -[hidden]-> bar4 : [hidden]
foo -[plain]-> bar5 : [plain]
@enduml
@startuml
title Bracketed line style mix
class foo
class bar
bar1 : [#red,thickness=1]
bar2 : [#red,dashed,thickness=2]
bar3 : [#green,dashed,thickness=4]
bar4 : [#blue,dotted,thickness=8]
bar5 : [#blue,plain,thickness=16]
foo --> bar : ∅
foo -[#red,thickness=1]-> bar1 : [#red,1]
foo -[#red,dashed,thickness=2]-> bar2 : [#red,dashed,2]
foo -[#green,dashed,thickness=4]-> bar3 : [#green,dashed,4]
foo -[#blue,dotted,thickness=8]-> bar4 : [blue,dotted,8]
foo -[#blue,plain,thickness=16]-> bar5 : [blue,plain,16]
@enduml
Change relation (linking or arrow) color and style (inline style)
You can change the color or style of individual relation or arrows using the inline following notation:
#color;line.[bold|dashed|dotted];text:color
@startuml
class foo
foo --> bar : normal
foo --> bar1 #line:red;line.bold;text:red : red bold
foo --> bar2 #green;line.dashed;text:green : green dashed
foo --> bar3 #blue;line.dotted;text:blue : blue dotted
@enduml
@startuml
abstract abstract
annotation annotation #pink;line:red;line.bold;text:red
class class #palegreen;line:green;line.dashed;text:green
interface interface #aliceblue;line:blue;line.dotted;text:blue
@enduml
First original example:
@startuml
class bar #line:green;back:lightblue
class bar2 #lightblue;line:green
class Foo1 #back:red;line:00FFFF
class FooDashed #line.dashed:blue
class FooDotted #line.dotted:blue
class FooBold #line.bold
class Demo1 #back:lightgreen|yellow;header:blue/red
@enduml
@startuml
left to right direction
class User {
id : INTEGER
..
other_id : INTEGER
}
class Email {
id : INTEGER
..
user_id : INTEGER
address : INTEGER
}
User::id *-- Email::user_id
@enduml
Theme
