Uml Class Diagram Method Returns Object

Klassendiagramm

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

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:

🎉 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

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

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

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

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

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

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

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.

🎉 Copied!

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

⚠ 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]

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

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

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

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.

🎉 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

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

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.

🎉 Copied!

@startuml class Foo1 class Foo2 Foo2 *-- Foo1 remove Foo2 @enduml

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]

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.

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

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

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

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

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

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

Ä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

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

Association on same class

🎉 Copied!

@startuml class Station { +name: string } class StationCrossing { +cost: TimeInterval } <> diamond StationCrossing . diamond diamond - "from 0..*" Station diamond - "to 0..* " Station @enduml

[Ref. Incubation: Associations]

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

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

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

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

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

Extends and implements

It is also possible to use extends and implements keywords.

🎉 Copied!

@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

🎉 Copied!

@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

🎉 Copied!

@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

[Adapted from QA-4181]

Line color

🎉 Copied!

@startuml title Bracketed line color 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

Line thickness

🎉 Copied!

@startuml title Bracketed line thickness 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]

Mix

🎉 Copied!

@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

🎉 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

[See similar feature on deployment]

Change class color and style (inline style)

You can change the color or style of individual class using the two following notations:

• #color ##[style]color

With background color first (#color), then line style and line color (##[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

First original example:

🎉 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]

Arrows from/to class members

🎉 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]

Grouping inheritance arrow heads

You can merge all arrow heads using the skinparam groupInheritance, with a threshold as parameter.

GroupInheritance 1 (no grouping)

🎉 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

GroupInheritance 2 (grouping from 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

GroupInheritance 3 (grouping only from 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

GroupInheritance 4 (grouping only from 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, and Defect QA-13532]

Source: https://plantuml.com/de/class-diagram

Posted by: frankinmakedaoes.blogspot.com

Berbagi :