Home Was gibt es Neues? Erste Schritte Online Server Running F.A.Q. Download Forum Theme Vorverarbeitung Standard Bibliothek Hitchhiker's Guide PDF Leitfaden
PlantUML Language specification Class Diagram

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Klassendiagramm

Klassendiagramme werden mit einer Syntax entworfen, die derjenigen ähnelt, die traditionell in Programmiersprachen verwendet wird. Diese Ähnlichkeit fördert eine vertraute Umgebung für Entwickler und erleichtert so die Erstellung von Diagrammen.

Dieser Designansatz ist nicht nur prägnant, sondern ermöglicht auch die Erstellung von Darstellungen, die sowohl prägnant als auch aussagekräftig sind. Darüber hinaus ermöglicht er die Darstellung von Beziehungen zwischen Klassen durch eine Syntax, die an die von Sequenzdiagrammen angelehnt ist, und ebnet so den Weg für eine flüssige und aufschlussreiche Darstellung von Klasseninteraktionen.

Über strukturelle und relationale Darstellungen hinaus unterstützt die Klassendiagrammsyntax weitere Anreicherungen wie das Einfügen von Notizen und die Anwendung von Farben, wodurch Benutzer in die Lage versetzt werden, Diagramme zu erstellen, die sowohl informativ als auch visuell ansprechend sind.

Sie können mehr über einige der gängigen Befehle in PlantUML erfahren, um Ihre Diagrammerstellung zu verbessern.

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Elemente deklarieren

🎉 Copied! 

@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

[Ref. for protocol and struct: GH-1028]

[Ref. for protocol and struct: GH-1028, for exception: QA-16258]

WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
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 gestrichelte Linie zu erhalten.

Wenn man diese Regeln kennt, ist es möglich, die folgenden Zeichnungen zu zeichnen:

🎉 Copied! 

@startuml
Class01 <|-- Class02
Class03 *-- Class04
Class05 o-- Class06
Class07 .. Class08
Class09 -- Class10
@enduml

🎉 Copied! 

@startuml
Class11 <|.. Class12
Class13 --> Class14
Class15 ..> Class16
Class17 ..|> Class18
Class19 <--* Class20
@enduml

🎉 Copied! 

@startuml
Class21 #-- Class22
Class23 x-- Class24
Class25 }-- Class26
Class27 +-- Class28
Class29 ^-- Class30
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Beschriften von Beziehungen

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.

🎉 Copied! 

@startuml

Class01 "1" *-- "many" Class02 : contains

Class03 o-- Class04 : aggregation

Class05 --> "1" Class06

@enduml

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.

🎉 Copied! 

@startuml
class Car

Driver - Car : drives >
Car *- Wheel : have 4 >
Car -- Person : < owns

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
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

🎉 Copied! 

@startuml
class "This is my class" as class1
class class2 as "It works this way too"

class2 *-- "foo/dummy" : use
@enduml

Also note that names starting with $ are valid, but to assign an alias to such element the name must be put between quotes "".
WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
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.

🎉 Copied! 

@startuml
Object <|-- ArrayList

Object : equals()
ArrayList : Object[] elementData
ArrayList : size()

@enduml

Es ist möglich in Klammern, Feldern und Methoden mit {} zu gruppieren

Die Syntax ist sehr flexibel bezüglich der Reihenfolge der Typen und Namen.

🎉 Copied! 

@startuml
class Dummy {
  String data
  void methods()
}

class Flight {
   flightNumber : Integer
   departureTime : Date
}
@enduml

Sie können die Modifier {field} und {method} verwenden, um das Standardverhalten des Parsers bei Feldern und Methoden zu übersteuern.

🎉 Copied! 

@startuml
class Dummy {
  {field} A field (despite parentheses)
  {method} Some method
}

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Sichtbarkeit festlegen

Beim Definieren von Methoden und Feldern kann die Sichtbarkeit mit einem der folgenden Zeichen festgelegt werden:

Character Icon for field Icon for method Visibility
- private
# protected
~ package private
+ public

🎉 Copied! 

@startuml

class Dummy {
 -field1
 #field2
 ~method1()
 +method2()
}

@enduml

Mit dem skinparam classAttributeIconSize 0 Befehl kann dieses Verhalten ausgeschaltet werden :

🎉 Copied! 

@startuml
skinparam classAttributeIconSize 0
class Dummy {
 -field1
 #field2
 ~method1()
 +method2()
}

@enduml

WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Abstract und Static

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.

🎉 Copied! 

@startuml
class Dummy {
  {static} String id
  {abstract} void methods()
}
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
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:

🎉 Copied! 

@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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
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.

🎉 Copied! 

@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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Mehr zu Notizen

Es ist auch möglich einige HTML Tags wie (See Creole expression):

  • <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.

🎉 Copied! 

@startuml

class Foo
note left: On last defined class

note top of Foo
  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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Note on field (field, attribute, member) or method

It is possible to add a note on field (field, attribute, member) or on method.

⚠ Constraint

  • This cannot be used with top or bottom (only left and right are implemented)
  • This cannot be used with namespaceSeparator ::

Note on field or method

🎉 Copied! 

@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

🎉 Copied! 

@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

[Ref. QA-3474 and QA-5835]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Notizen zu Beziehungen

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.

🎉 Copied! 

@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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
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.

🎉 Copied! 

@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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
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 oder 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.

🎉 Copied! 

@startuml

class Dummy1 {
  +myMethods()
}

class Dummy2 {
  +hiddenMethod()
}

class Dummy3 <<Serializable>> {
String name
}

hide members
hide <<Serializable>> circle
show Dummy1 methods
show <<Serializable>> fields

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
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.

🎉 Copied! 

@startuml

class Foo1
class Foo2

Foo2 *-- Foo1

hide Foo2

@enduml

WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Klassen entfernen

Sie können auch den Befehl remove verwenden, um Klassen zu entfernen.

Dies kann nützlich sein, wenn Sie eine große !included-Datei definieren, und wenn Sie einige Klassen nach dem einbinden der Datei entfernen möchten.

🎉 Copied! 

@startuml

class Foo1
class Foo2

Foo2 *-- Foo1

remove Foo2

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Hide, Remove or Restore tagged element or wildcard

You can put $tags (using $) on elements, then remove, hide or restore components either individually or by tags.

By default, all components are displayed:

🎉 Copied! 

@startuml
class C1 $tag13
enum E1
interface I1 $tag13
C1 -- I1
@enduml

But you can:
  • hide $tag13 components:

🎉 Copied! 

@startuml
class C1 $tag13
enum E1
interface I1 $tag13
C1 -- I1

hide $tag13
@enduml

  • or remove $tag13 components:

🎉 Copied! 

@startuml
class C1 $tag13
enum E1
interface I1 $tag13
C1 -- I1

remove $tag13
@enduml

  • or remove $tag13 and restore $tag1 components:

🎉 Copied! 

@startuml
class C1 $tag13 $tag1
enum E1
interface I1 $tag13
C1 -- I1

remove $tag13
restore $tag1
@enduml

  • or remove * and restore $tag1 components:

🎉 Copied! 

@startuml
class C1 $tag13 $tag1
enum E1
interface I1 $tag13
C1 -- I1

remove *
restore $tag1
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Hide or Remove unlinked class

By default, all classes are displayed:

🎉 Copied! 

@startuml
class C1
class C2
class C3
C1 -- C2
@enduml

But you can:
  • hide @unlinked classes:

🎉 Copied! 

@startuml
class C1
class C2
class C3
C1 -- C2

hide @unlinked
@enduml

  • or remove @unlinked classes:

🎉 Copied! 

@startuml
class C1
class C2
class C3
C1 -- C2

remove @unlinked
@enduml

[Adapted from QA-11052]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Verwenden von Generics

Mit spitzen Klammern ( < und >) kann die Verwendung von Generics dargestellt werden.

🎉 Copied! 

@startuml

class Foo<? extends Element> {
  int size()
}
Foo *- Element

@enduml

Man kann diese Darstellung mittels des Befehls skinparam genericDisplay old ausschalten.

Edit in DokuwikiEdit in AsciidocEdit in Markdown
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:

🎉 Copied! 

@startuml

class System << (S,#FF7700) Singleton >>
class Date << (D,orchid) >>
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
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.

🎉 Copied! 

@startuml

package "Classic Collections" #DDDDDD {
  Object <|-- ArrayList
}

package net.sourceforge.plantuml {
  Object <|-- Demo1
  Demo1 *- Demo2
}

@enduml

WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Paketarten

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.

🎉 Copied! 

@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:

🎉 Copied! 

@startuml

skinparam packageStyle rectangle

package foo1.foo2 {
}

package foo1.foo2.foo3 {
  class Object
}

foo1.foo2 +-- foo1.foo2.foo3

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Namensraum

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.

🎉 Copied! 

@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

There won't be any difference between namespaces and packages anymore: both keywords are now synonymous.

WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Automatische Erzeugung eines Namensraums

Über folgenden Befehl kann ein anderes Trennzeichen (als der Punkt) definiert werden: set namespaceSeparator ???.

🎉 Copied! 

@startuml

set namespaceSeparator ::
class X1::X2::foo {
  some info
}

@enduml

Die automatische Erzeugung eines Pakets kann mit set namespaceSeparator none deaktiviert werden.

🎉 Copied! 

@startuml

set namespaceSeparator none
class X1.X2.foo {
  some info
}

@enduml

WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Lollipop Schnittstellen

Mit der folgenden Syntax kann man Schnittstellen von Klassen definieren:
  • bar ()- foo
  • bar ()-- foo
  • foo -() bar

🎉 Copied! 

@startuml
class foo
bar ()- foo
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Ä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:

🎉 Copied! 

@startuml
Room o- Student
Room *-- Chair
@enduml

Man kann die Richtung auch durch das Umdrehen der Verbindung ändern:

🎉 Copied! 

@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:

🎉 Copied! 

@startuml
foo -left-> dummyLeft
foo -right-> dummyRight
foo -up-> dummyUp
foo -down-> dummyDown
@enduml

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.

WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Assoziationsklassen

Nach dem man eine Beziehung zwischen zwei Klassen definiert hat, kann man eine association class definieren. Hierzu ein Beispiel:

🎉 Copied! 

@startuml
class Student {
  Name
}
Student "0..*" - "1..*" Course
(Student, Course) .. Enrollment

class Enrollment {
  drop()
  cancel()
}
@enduml

Die Richtung lässt ich aber auch ändern:

🎉 Copied! 

@startuml
class Student {
  Name
}
Student "0..*" -- "1..*" Course
(Student, Course) . Enrollment

class Enrollment {
  drop()
  cancel()
}
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Assoziation in derselben Klasse

🎉 Copied! 

@startuml
class Station {
    +name: string
}

class StationCrossing {
    +cost: TimeInterval
}

<> diamond

StationCrossing . diamond
diamond - "from 0..*" Station
diamond - "to 0..* " Station
@enduml

[Ref. Inkubation: Assoziationen]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Der Skinparam-Befehl

Mit dem skinparam Befehl kann die Farbe und die Schriftart der Zeichnung verändert werden.

Sie können den Befehl auf die folgenden Arten verwenden:
  • Wie alle ander Befehle In einer Diagrammdefinition,
  • in einer Include-Datei,
  • In einer Konfigurationsdatei, die durch die Kommandozeile oder den ANT-Task übergeben wird.

🎉 Copied! 

@startuml

skinparam class {
BackgroundColor PaleGreen
ArrowColor SeaGreen
BorderColor SpringGreen
}
skinparam stereotypeCBackgroundColor YellowGreen

Class01 "1" *-- "many" Class02 : contains

Class03 o-- Class04 : aggregation

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Das Aussehen von Stereotypen verändern

Es ist möglich die Farbe und die Schriftart der Klassen zu verändern, die mit einem Stereotypen ausgezeichnet sind.

🎉 Copied! 

@startuml

skinparam class {
BackgroundColor PaleGreen
ArrowColor SeaGreen
BorderColor SpringGreen
BackgroundColor<<Foo>> Wheat
BorderColor<<Foo>> Tomato
}
skinparam stereotypeCBackgroundColor YellowGreen
skinparam stereotypeCBackgroundColor<< Foo >> DimGray

Class01 <<Foo>>
Class03 <<Foo>>
Class01 "1" *-- "many" Class02 : contains

Class03 o-- Class04 : aggregation

@enduml

Any of the spaces shown as `_` below will cause all skinparams to be ignored, see [discord discussion](https://discord.com/channels/1083727021328306236/1289954399321329755/1289967399302467614) and [issue #1932](https://github.com/plantuml/plantuml/issues/1932):
  • `BackgroundColor_<<Foo>> Wheat`
  • `skinparam stereotypeCBackgroundColor_<<Foo>> DimGray`
WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Farbverlauf

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:

🎉 Copied! 

@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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
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.

🎉 Copied! 

@startuml

class Bar1
class Bar2
together {
  class Together1
  class Together2
  class Together3
}
Together1 - Together2
Together2 - Together3
Together2 -[hidden]--> Bar1
Bar1 -[hidden]> Bar2


@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
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)

🎉 Copied! 

@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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Extends und Implements

Es ist auch möglich, die Schlüsselwörter extends und implements zu verwenden.

🎉 Copied! 

@startuml
class ArrayList implements List
class ArrayList extends AbstractList
@enduml

*[Ref. [QA-2239](https://forum.plantuml.net/2239/is-multiple-inheritance-or-implementation-possible)]*
WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Design Möglichkeiten für Beziehungen (Verknüpfungen oder Pfeile)

Linienstil

Es ist möglich einen expliziten Stil für Beziehungen (Verknüpfungen oder Pfeile) zu verwenden bold, dashed, dotted, hidden oder plain :

  • ohne Label

🎉 Copied! 

@startuml
title Linienstile ohne Beschriftung
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

  • mit Beschriftung

🎉 Copied! 

@startuml
title Linienstile mit Beschriftung
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

[Angepasst von QA-4181]

Linienfarbe

🎉 Copied! 

@startuml
title Farbige Linien
class foo
class bar
bar1 : [#red]
bar2 : [#green]
bar3 : [#blue]

foo --> bar
foo -[#red]-> bar1     : [#red]
foo -[#green]-> bar2   : [#green]
foo -[#blue]-> bar3    : [#blue]
'foo -[#blue;#yellow;#green]-> bar4
@enduml

Linienstärke

🎉 Copied! 

@startuml
title Unterschiedlich dicke Linien
class foo
class bar
bar1 : [thickness=1]
bar2 : [thickness=2]
bar3 : [thickness=4]
bar4 : [thickness=8]
bar5 : [thickness=16]

foo --> bar                 : ∅
foo -[thickness=1]-> bar1   : [1]
foo -[thickness=2]-> bar2   : [2]
foo -[thickness=4]-> bar3   : [4]
foo -[thickness=8]-> bar4   : [8]
foo -[thickness=16]-> bar5  : [16]

@enduml

[Ref. QA-4949]

Mischung

🎉 Copied! 

@startuml
title Gemischte Designs
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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Ändern der Farbe und des Stils von Beziehungen (Verknüpfungen oder Pfeilen) (Inline-Stil)

Sie können die Farbe oder den Stil einzelner Beziehungen oder Pfeile ändern, indem Sie die folgende Inline-Notation verwenden:

  • #color;line.[bold|dashed|dotted];text:color

🎉 Copied! 

@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

[Siehe ähnliche Funktion bei der Bereitstellung]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Ändern der Farbe und des Stils einer Klasse (Inline-Stil)

Sie können die Farbe oder den Stil einer einzelnen Klasse mit den beiden folgenden Notationen ändern:

  • #color ##[style]color

Zuerst mit der Hintergrundfarbe (#color), dann mit dem Zeilenstil und der Zeilenfarbe (##[style]color )

🎉 Copied! 

@startuml
abstract   abstract
annotation annotation #pink ##[bold]red
class      class      #palegreen ##[dashed]green
interface  interface  #aliceblue ##[dotted]blue
@enduml

[Ref. QA-1487]

  • #[color|back:color];header:color;line:color;line.[bold|dashed|dotted];text:color

🎉 Copied! 

@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

Erstes Originalbeispiel:

🎉 Copied! 

@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

[Ref. QA-3770]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Pfeile von/zu Klassen Attributen und Methoden

🎉 Copied! 

@startuml
class Foo {
+ field1
+ field2
}

class Bar {
+ field3
+ field4
}

Foo::field1 --> Bar::field3 : foo
Foo::field2 --> Bar::field4 : bar
@enduml

[Ref. QA-3636]

🎉 Copied! 

@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

[Ref. QA-5261]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Gruppierung von Vererbungspfeilspitzen

Sie können alle Pfeilspitzen mit Hilfe von skinparam groupInheritance zusammenfassen, mit einem Schwellenwert als Parameter.

GroupInheritance 1 (keine Gruppierung)

🎉 Copied! 

@startuml
skinparam groupInheritance 1

A1 <|-- B1

A2 <|-- B2
A2 <|-- C2

A3 <|-- B3
A3 <|-- C3
A3 <|-- D3

A4 <|-- B4
A4 <|-- C4
A4 <|-- D4
A4 <|-- E4
@enduml

Gruppenvererbung 2 (Gruppierung ab 2)

🎉 Copied! 

@startuml
skinparam groupInheritance 2

A1 <|-- B1

A2 <|-- B2
A2 <|-- C2

A3 <|-- B3
A3 <|-- C3
A3 <|-- D3

A4 <|-- B4
A4 <|-- C4
A4 <|-- D4
A4 <|-- E4
@enduml

Gruppenvererbung 3 (Gruppierung nur ab 3)

🎉 Copied! 

@startuml
skinparam groupInheritance 3

A1 <|-- B1

A2 <|-- B2
A2 <|-- C2

A3 <|-- B3
A3 <|-- C3
A3 <|-- D3

A4 <|-- B4
A4 <|-- C4
A4 <|-- D4
A4 <|-- E4
@enduml

Gruppenvererbung 4 (Gruppierung nur ab 4)

🎉 Copied! 

@startuml
skinparam groupInheritance 4

A1 <|-- B1

A2 <|-- B2
A2 <|-- C2

A3 <|-- B3
A3 <|-- C3
A3 <|-- D3

A4 <|-- B4
A4 <|-- C4
A4 <|-- D4
A4 <|-- E4
@enduml

[Ref. QA-3193, und Defekt QA-13532]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Anzeige von JSON-Daten im Klassen- oder Objektdiagramm

Einfaches Beispiel

🎉 Copied! 

@startuml
class Class
object Object
json JSON {
   "fruit":"Apple",
   "size":"Large",
   "color": ["Red", "Green"]
}
@enduml

[Ref. QA-15481]

Ein weiteres Beispiel finden Sie auf der Seite JSON.

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Packages and Namespaces Enhancement

[From V1.2023.2+, and V1.2023.5]

🎉 Copied! 

@startuml
class A.B.C.D.Z {
}
@enduml

🎉 Copied! 

@startuml
set separator none
class A.B.C.D.Z {
}
@enduml

🎉 Copied! 

@startuml
!pragma useIntermediatePackages false
class A.B.C.D.Z {
}
@enduml

🎉 Copied! 

@startuml
set separator none
package A.B.C.D {
  class Z {
  }
}
@enduml

[Ref. GH-1352]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Qualified associations

Minimal example

🎉 Copied! 

@startuml
class class1
class class2

class1 [Qualifier] - class2
@enduml

[Ref. QA-16397, GH-1467]

Another example

🎉 Copied! 

@startuml
    interface Map<K,V>
    class HashMap<Long,Customer>

    Map <|.. HashMap
    Shop [customerId: long] ---> "customer\n1" Customer
    HashMap [id: Long] -r-> "value" Customer
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Change diagram orientation

You can change (whole) diagram orientation with:
  • top to bottom direction (by default)
  • left to right direction

Top to bottom (by default)

With Graphviz (layout engine by default)

The main rule is: Nested element first, then simple element.

🎉 Copied! 

@startuml
class a
class b
package A {
  class a1
  class a2
  class a3
  class a4
  class a5
  package sub_a {
   class sa1
   class sa2
   class sa3
  }
}
  
package B {
  class b1
  class b2
  class b3
  class b4
  class b5
  package sub_b {
   class sb1
   class sb2
   class sb3
  }
}
@enduml

With Smetana (internal layout engine)

The main rule is the opposite: Simple element first, then nested element.

🎉 Copied! 

@startuml
!pragma layout smetana
class a
class b
package A {
  class a1
  class a2
  class a3
  class a4
  class a5
  package sub_a {
   class sa1
   class sa2
   class sa3
  }
}
  
package B {
  class b1
  class b2
  class b3
  class b4
  class b5
  package sub_b {
   class sb1
   class sb2
   class sb3
  }
}
@enduml

Left to right

With Graphviz (layout engine by default)

🎉 Copied! 

@startuml
left to right direction
class a
class b
package A {
  class a1
  class a2
  class a3
  class a4
  class a5
  package sub_a {
   class sa1
   class sa2
   class sa3
  }
}
  
package B {
  class b1
  class b2
  class b3
  class b4
  class b5
  package sub_b {
   class sb1
   class sb2
   class sb3
  }
}
@enduml

With Smetana (internal layout engine)

🎉 Copied! 

@startuml
!pragma layout smetana
left to right direction
class a
class b
package A {
  class a1
  class a2
  class a3
  class a4
  class a5
  package sub_a {
   class sa1
   class sa2
   class sa3
  }
}
  
package B {
  class b1
  class b2
  class b3
  class b4
  class b5
  package sub_b {
   class sb1
   class sb2
   class sb3
  }
}
@enduml

Privacy Policy      Advertise