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.
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.
@startuml
class Car
Driver - Car : drives >
Car *- Wheel : have 4 >
Car -- Person : < owns
@enduml
Añadiendo métodos
Para declarar las propiedades y métodos, se puede usar el símbolo : seguido del nombre de la propiedad o el método. El sistema busca por paréntesis para elegir entre métodos y propiedades.
También es posible agrupar entre llaves {} todos las propiedades y métodos. Tenga en cuenta que la sintexis es muy flexible acerca del orden tipo/nombre.
@startuml
class Dummy {
String data
void methods()
}
class Flight {
flightNumber : Integer
departureTime : Date
}
@enduml
Puede usar los modificadores {field} y {method} para modificar el comportamiento por defecto del parse sobre los campos y métodos.
@startuml
class Dummy {
{field} A field (despite parentheses)
{method} Some method
}
@enduml
Definiendo la visibilidad
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
@startuml
class Dummy {
-field1
#field2
~method1()
+method2()
}
@enduml
Puedes desactivar esta característica usando el comando skinparam classAttributeIconSize 0 :
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}.
@startuml
class Dummy {
{static} String id
{abstract} void methods()
}
@enduml
Cuerpo avanzado de las clases
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:
@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
Notas y estereotipos
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 ...
@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
Más acerca de notas
También es posible usar algunas etiquetas HTML como:
<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.
@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
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.
@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
Clases abstractas e interfaces
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 .
@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)]*
Utilizar la palabra reservada as en la definición de la clase
Colocar comillas "" alrededor del nombre de la clase
@startuml
class "This is my class" as class1
class class2 as "It works this way too"
class2 *-- "foo/dummy" : use
@enduml
Atributos, métodos... ocultos
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.
@startuml
class Dummy1 {
+myMethods()
}
class Dummy2 {
+hiddenMethod()
}
class Dummy3 <<Serializable>> {
String name
}
hide members
hide <<Serializable>> circle
show Dummy1 methods
show <<Serializable>> fields
@enduml
Clases ocultas
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.
@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
También puedes usar los signos menor < y mayor > para definir el uso de clases genéricas.
@startuml
class Foo<? extends Element> {
int size()
}
Foo *- Element
@enduml
Es posible desactivar este dibujo con el comando skinparam genericDisplay old.
Círculo enmarcador específico
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:
@startuml
class System << (S,#FF7700) Singleton >>
class Date << (D,orchid) >>
@enduml
Paquetes
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.
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.
@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:
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.
@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
Creación automática del espacio de nombre
Puedes definir otro separador (otro además del punto) usando el comando : set namespaceSeparator ???.
@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.
@startuml
set namespaceSeparator none
class X1.X2.foo {
some info
}
@enduml
Interface Lollipop
También puedes definir interfaces lollipops en clases, usando la siguiente sintaxsis:
bar ()- foo
bar ()-- foo
foo -() bar
@startuml
class foo
bar ()- foo
@enduml
Cambiando la dirección de las flechas
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í:
@startuml
Room o- Student
Room *-- Chair
@enduml
También puedes cambiar las direcciones revirtiendo el enlace:
@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:
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.
Asociación de clases
Puedes definir association class después de que una relación haya sido establecida entre dos clases, como en este ejemplo:
@startuml
class Student {
Name
}
Student "0..*" - "1..*" Course
(Student, Course) .. Enrollment
class Enrollment {
drop()
cancel()
}
@enduml
Puedes definirla en otra dirección:
@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
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:
|,
/,
\,
o -
dependiendo de la dirección del degradado. Por ejemplo, podrías tener:
@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
Ayudar en el diseño
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.
@startuml
class Bar1
class Bar2
together {
class Together1
class Together2
class Together3
}
Together1 - Together2
Together2 - Together3
Together2 -[hidden]--> Bar1
Bar1 -[hidden]> Bar2
@enduml
Dividiendo archivos grandes
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).
@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
