🎉 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
protocol protocol
struct struct
@enduml
|
[Ref. para protocol y struct: GH-1028] *[Ref. for ``protocol`` and ``struct``: [GH-1028](https:github.com/plantuml/plantuml/pull/1028), for ``exception``: [QA-16258](https:forum.plantuml.net/16258/adding-exception-keyword-for-class-diagram)]* WARNING This translation need to be updated. WARNING Las relaciones entre clases se definen usando los siguientes símbolos: | Type | Symbol | Drawing | | Extension | <|-- |  | | Composition | *-- |  | | Aggregation | o-- |  |
Es posible intercambiar -- por .. para tener lineas punteadas. Sabiendo esas reglas, es posible sacar los siguientes dibujos: 🎉 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
|
Es posible añadir etiquetas en las relaciones, usando :, seguido del texto de la etiqueta. Para la cardinalidad, puede usar comillas dobles "" en cada lado de la relación. 🎉 Copied!
| @startuml
Class01 "1" *-- "many" Class02 : contains
Class03 o-- Class04 : aggregation
Class05 --> "1" Class06
@enduml
|
Se puede añadir una flecha extra apuntando a un objeto, mostrando que objeto actúa sobre el otro objeto, usando < o > al inicio o al final de la etiqueta. 🎉 Copied!
| @startuml
class Car
Driver - Car : drives >
Car *- Wheel : have 4 >
Car -- Person : < owns
@enduml
|
Si no desea usar letras en la visualización de la clase (o enum...), puede: - Utilizar la palabra reservada
as en la definición de la clase - Colocar comillas
"" alrededor del nombre de la clase
🎉 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 Para declarar campos y métodos, se puede utilizar el símbolo : seguido del nombre del campo o del método. El sistema busca paréntesis para elegir entre métodos y campos 🎉 Copied!
| @startuml
Object <|-- ArrayList
Object : equals()
ArrayList : Object[] elementData
ArrayList : size()
@enduml
|
También es posible agrupar entre paréntesis {} todos los campos y métodos. Tenga en cuenta que la sintaxis es muy flexible en cuanto al orden tipo/nombre. 🎉 Copied!
| @startuml
class Dummy {
String data
void methods()
}
class Flight {
flightNumber : Integer
departureTime : Date
}
@enduml
|
Puedes utilizar los modificadores {field} y {method} para anular el comportamiento por defecto del analizador sintáctico sobre los campos y métodos 🎉 Copied!
| @startuml
class Dummy {
{field} A field (despite parentheses)
{method} Some method
}
@enduml
|
Cuando defines propiedades o métodos, puedes usar caracteres para establecer la visibilidad que les correspondan: | Character | Icon for field | Icon for method | Visibility | - |  |  | private | # |  |  | protected | ~ |  |  | package private | + |  |  | public |
🎉 Copied!
| @startuml
class Dummy {
-field1
#field2
~method1()
+method2()
}
@enduml
|
Puedes desactivar esta característica usando el comando skinparam classAttributeIconSize 0 : 🎉 Copied!
| @startuml
skinparam classAttributeIconSize 0
class Dummy {
-field1
#field2
~method1()
+method2()
}
@enduml
|
WARNING This translation need to be updated. WARNING Puedes definir métodos o propiedades abstractas y estáticas usando los modificadores {static} o {abstract} . Esos modificadores pueden ser usado al comienzo o al final de un línea. También puedes usar {classifier} en lugar de {static}. 🎉 Copied!
| @startuml
class Dummy {
{static} String id
{abstract} void methods()
}
@enduml
|
Por defecto, las propiedades y los métodos son agrupados automáticamente por PlantUML. Puedes usar separadores para definir tu propia manera de ordenar las propiedades y los métodos. Son posibles los siguientes separadores: --..==__. También puedes definir títulos dentro de los separadores: 🎉 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
|
Los estereotipos son definidos con la palabra clave class, << and >>. También puedes definir notas usando las palabras claves note left of , note right of , note top of , note bottom of . Además puedes definir una nota en la última clase definida usando note left, note right, note top, note bottom . Una nota también puede definirse solitariamente con la palabra clave note, y a continuación relacionarla con otro objeto usando el símbolo ... 🎉 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
|
También es posible usar algunas etiquetas HTML como (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
También puedes tener una nota en varias líneas. És possible definir una nota en la última clase definida usando note left, note right, note top, note bottom. 🎉 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
|
WARNING This translation need to be updated. WARNING 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] Es posible añadir una nota en un enlace, justo después de la definición de dicho enlace, usando note on link . También puedes usar note left on link, note right on link, note top on link, note bottom on link si quieres cambiar la posición de la nota, en relación a una etiqueta. 🎉 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
|
Puedes declarar una clase como abstracta usando las palabras claves abstract or abstract class . La clase será impresa en italic . Puedes usar también las palabras claves interface, annotation and enum . 🎉 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 Puede parametrizar la visualización de las clases usando el comando hide/show . El comando básico es: hide empty members. Este comando ocultará atributos y métodos si están vacíos. En lugar de empty members , puedes usar: empty fields o empty attributes para atributos vacíos.empty methods para métodos vacíos,fields o attributes que ocultará atributos, incluso si son descritos,methods que ocultará métodos, incluso si son descritos,members que ocultará atributos y métodos, incluso si son descritos.circle para el carácter encerrado en un círculo, en frente del nombre de clase.stereotype para el estereotipo.
También puede proporcionar, justo después las palabras clave hide o show: class para todas las clases,interface para todas las interfaces,enum para todos los enums,<<foo1>> para clases que son estereotipadas con foo1,- un nombre de clase existente.
Puedes usar varios comandos show/hide para definir reglas y excepciones. 🎉 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
|
También puedes usar el comando show/hide para ocultar clases. Esto puede llegar a ser útil si defines una archivo !included muy grande y si deseas ocultar algunas clases después de la inclusión de dicho archivo. 🎉 Copied!
| @startuml
class Foo1
class Foo2
Foo2 *-- Foo1
hide Foo2
@enduml
|
WARNING This translation need to be updated. WARNING 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
|
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: 🎉 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
|
By default, all classes are displayed: 🎉 Copied!
| @startuml
class C1
class C2
class C3
C1 -- C2
@enduml
|
But you can: 🎉 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] También puedes usar los signos menor < y mayor > para definir el uso de clases genéricas. 🎉 Copied!
| @startuml
class Foo<? extends Element> {
int size()
}
Foo *- Element
@enduml
|
Es posible desactivar este dibujo con el comando skinparam genericDisplay old. Usualmente, un carácter enmarcado en un círculo (C,I,E o A) es usado por clases, interfaces, enum y clases abstractas. Pero puedes definir tu propio enmarcado para una clase cuando defines un estereotipo, añadiendo un carácter y un color, así como en el ejemplo: 🎉 Copied!
| @startuml
class System << (S,#FF7700) Singleton >>
class Date << (D,orchid) >>
@enduml
|
Puedes definir un paquete usando la palabra reservada package, y opcionalmente declarar un color de fondo para tu paquete (Usando el nombre o el código HTML del color). Tenga en cuenta que las definiciones de paquetes pueden ser anidadas. 🎉 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 Hay diferentes estilos disponibles para paquetes. Puedes especificarlos, ya sea configurando un estilo por defecto con el comando : skinparam packageStyle , o usando un estereotipo en el paquete. 🎉 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
|
Puedes también definir enlaces entre paquetes, como en el siguiente ejemplo: 🎉 Copied!
| @startuml
skinparam packageStyle rectangle
package foo1.foo2 {
}
package foo1.foo2.foo3 {
class Object
}
foo1.foo2 +-- foo1.foo2.foo3
@enduml
|
En los paquetes, el nombre de una clase es el único identificador de esta clase. Quiere decir que no puedes tener dos clases con el mismo nombre en diferentes paquetes. En este caso, deberías usar espacios de nombres en lugar de paquetes. Puedes referir a clases de otros espacios de nombre describiendo su ruta completamente. A clases del espacio de nombre por defecto son descritas colocando un punto al inicio. Tenga en cuenta que no tiene que especificar explícitamente un espacio de nombre : una clase altamente clasificada es automáticamente colocada en el espacio de nombre correcto. 🎉 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 Puedes definir otro separador (otro además del punto) usando el comando : set namespaceSeparator ???. 🎉 Copied!
| @startuml
set namespaceSeparator ::
class X1::X2::foo {
some info
}
@enduml
|
Puedes deshabilitar la creación automática de paquetes usando el comando set namespaceSeparator none. 🎉 Copied!
| @startuml
set namespaceSeparator none
class X1.X2.foo {
some info
}
@enduml
|
WARNING This translation need to be updated. WARNING También puedes definir interfaces lollipops en clases, usando la siguiente sintaxsis: bar ()- foobar ()-- foofoo -() bar
🎉 Copied!
| @startuml
class foo
bar ()- foo
@enduml
|
Por defecto, enlaces entre clases tienen dos guiones -- y son verticalemnte orientados. Es posible usar un enlace horizontal colocando un solo guión (o punto), así: 🎉 Copied!
| @startuml
Room o- Student
Room *-- Chair
@enduml
|
También puedes cambiar las direcciones revirtiendo el enlace: 🎉 Copied!
| @startuml
Student -o Room
Chair --* Room
@enduml
|
También es posible cambiar la dirección de la flecha añadiendo las palabras claves left, right, up or down dentro de la flecha: 🎉 Copied!
| @startuml
foo -left-> dummyLeft
foo -right-> dummyRight
foo -up-> dummyUp
foo -down-> dummyDown
@enduml
|
Puedes acortar la flecha usando el primer carácter de la dirección (por ejemplo, -d- en lugar de -down-) o los primeros dos caracteres. Por favor tenga en cuenta que no debería abusar de esta funcionalidad : Graphviz usualmente otorga buenos resultados sin necesidad de ajustar. WARNING This translation need to be updated. WARNING Puedes definir association class después de que una relación haya sido establecida entre dos clases, como en este ejemplo: 🎉 Copied!
| @startuml
class Student {
Name
}
Student "0..*" - "1..*" Course
(Student, Course) .. Enrollment
class Enrollment {
drop()
cancel()
}
@enduml
|
Puedes definirla en otra dirección: 🎉 Copied!
| @startuml
class Student {
Name
}
Student "0..*" -- "1..*" Course
(Student, Course) . Enrollment
class Enrollment {
drop()
cancel()
}
@enduml
|
🎉 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] Puedes usar el comando skinparam para cambiar los colores y fuentes en el diagrama. Puedes usar este comando: 🎉 Copied!
| @startuml
skinparam class {
BackgroundColor PaleGreen
ArrowColor SeaGreen
BorderColor SpringGreen
}
skinparam stereotypeCBackgroundColor YellowGreen
Class01 "1" *-- "many" Class02 : contains
Class03 o-- Class04 : aggregation
@enduml
|
Puedes definir colores y fuentes específicas para clases esterotipadas. 🎉 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
|
Es posible declarar colores individuales para clases o notas usando la notación #. Puedes usar el nombre estándar del color o el código RGB. También puedes usar degradación de color en el fondo, con la siguiente sintaxis: dos nombres de colores separados por cualquier de los siguientes: dependiendo de la dirección del degradado. Por ejemplo, podrías tener: 🎉 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 Sometimes, the default layout is not perfect... You can use together keyword to group some classes together : the layout engine will try to group them (as if they were in the same package). You can also use hidden links to force the layout. 🎉 Copied!
| @startuml
class Bar1
class Bar2
together {
class Together1
class Together2
class Together3
}
Together1 - Together2
Together2 - Together3
Together2 -[hidden]--> Bar1
Bar1 -[hidden]> Bar2
@enduml
|
A veces, puedes obtener imágenes bastante grandes. Puedes usar el comando page (hpages)x(vpages) para dividir la imágen generada, en varias imágenes: hpages es el número que indica la cantidad de páginas horizontales, y vpages es el número que indica la cantidad de páginas verticales. También puede utilizar algunos ajustes específicos skinparam poner fronteras en las páginas splitted (ver ejemplo). 🎉 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
|
It is also possible to use extends and implements keywords. 🎉 Copied!
| @startuml
class ArrayList implements List
class ArrayList extends AbstractList
@enduml
|
Line style It's also possible to have explicitly bold, dashed, dotted, hidden or plain relation, links or arrows:
🎉 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
|
🎉 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
|
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] You can change the color or style of individual class using the two following notations: 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] 🎉 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] 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]Simple example 🎉 Copied!
| @startuml
class Class
object Object
json JSON {
"fruit":"Apple",
"size":"Large",
"color": ["Red", "Green"]
}
@enduml
|
[Ref. QA-15481] For another example, see on JSON page. | |
Edit in Dokuwiki
Edit in Asciidoc
Edit in Markdown
Relación entre clases
