Home What's New ? Getting Started Online Server Running F.A.Q. Download Forum Theme Preprocessing Standard Library Hitchhiker's Guide PDF Guide
PlantUML Language specification Class Diagram

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Diagrama de clase

Los diagramas de clase se diseñan utilizando una sintaxis que refleja la empleada tradicionalmente en los lenguajes de programación. Este parecido fomenta un entorno familiar para los desarrolladores, facilitando así un proceso de creación de diagramas más sencillo e intuitivo.

Este enfoque de diseño no sólo es sucinto, sino que también permite crear representaciones que son a la vez concisas y expresivas. Por otra parte, permite la representación de las relaciones entre las clases a través de una sintaxis que se hace eco de la de los diagramas de secuencia, allanando el camino para una representación fluida y perspicaz de las interacciones de clase.

Más allá de las representaciones estructurales y relacionales, la sintaxis de los diagramas de clase soporta enriquecimientos adicionales, tales como la inclusión de notas y la aplicación de colores, permitiendo a los usuarios crear diagramas que son a la vez informativos y visualmente atractivos.

Usted puede aprender más acerca de algunos de los comandos comunes en PlantUML para mejorar su experiencia de creación de diagramas.

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Elemento declarante

🎉 Copied! 

@startuml
abstract        abstract
abstract class  "abstract class"
annotation      annotation
circle          circle
()              circle_short_form
class           class
class           class_stereo  <<stereotype>>
diamond         diamond
<>              diamond_short_form
entity          entity
enum            enum
exception       exception
interface       interface
metaclass       metaclass
protocol        protocol
stereotype      stereotype
struct          struct
@enduml

[Ref. para protocol y struct: GH-1028, para exception: QA-16258]

*[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), for ``record ``and ``dataclass`` : [GH-2232](https://github.com/plantuml/plantuml/pull/2232)]*
WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Relación entre clases

Las relaciones entre clases se definen usando los siguientes símbolos:

Tipo Símbolo Finalidad
Extensión <|-- Especialización de una clase en una jerarquía
Implementación <|.. Realización de una interfaz mediante una clase
Composición *-- La parte no puede existir sin el todo
Agregación o-- La parte puede existir independientemente del todo
Dependencia --> El objeto utiliza otro objeto
Dependencia ..> Una forma más débil de dependencia

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

WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Etiqueta en las relaciones

Es posible añadir una etiqueta en la relación, utilizando :, seguido por el texto de la etiqueta.

Para la cardinalidad, puede utilizar comillas dobles "" a 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 adicional apuntando a un objeto que muestre qué objeto actúa sobre el otro objeto, utilizando < o > al principio o al final de la etiqueta.

🎉 Copied! 

@startuml
class Car

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

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Sin usar letras

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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Añadir métodos

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

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

🎉 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

*[Ref. [QA-4755](https://forum.plantuml.net/4755/provide-display-visibility-attributes-private-protected)]*
WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Abstracto y Estático

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

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

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

🎉 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
Más acerca de notas

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

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
Notas en enlaces

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

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

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

🎉 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

*[Ref. [QA-2913](https://forum.plantuml.net/2913/hiding-based-on-visibilty?show=2916#a2916)]*
WARNING
 This translation need to be updated. 
WARNING

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

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

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
Uso de clases genéricas

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.

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

🎉 Copied! 

@startuml

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

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

🎉 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
Estilos de paquetes

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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Espacios de nombre

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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Creación automática del espacio de nombre

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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Interface Lollipop

También puedes definir interfaces lollipops en clases, usando la siguiente sintaxsis:
  • bar ()- foo
  • bar ()-- foo
  • foo -() bar

🎉 Copied! 

@startuml
class foo
bar ()- foo
@enduml

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

🎉 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

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

🎉 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

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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Personalización (Skinparam)

Puedes usar el comando skinparam para cambiar los colores y fuentes en el diagrama.

Puedes usar este comando:
  • En la definición del diagrama, como cualquier otro comando,
  • En un archivo incluido,
  • En un archivo de configuración, proporcionado en la consola de comandos o en el ANT task.

🎉 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
Estereotipos personalizados

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

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
Degrado de colores

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:

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

🎉 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
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).

🎉 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 and implements

It is also possible to use extends and implements keywords.

🎉 Copied! 

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

🎉 Copied! 

@startuml
class A extends B, C {
}
@enduml

[Ref. QA-2239]

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

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

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

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

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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Display JSON Data on Class or Object diagram

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 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
Cambiar la orientación del diagrama

Puede cambiar la orientación (completa) del diagrama con:
  • top to bottom direction (por defecto)
  • left to right direction

De arriba a abajo (por defecto)

Con Graphviz (motor de diseño por defecto)

La regla principal es: Elemento anidado primero, luego elemento simple.

🎉 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

Con Smetana ( motor de diseño interno)

La regla principal es la contraria: Elemento simple primero, luego elemento anidado.

🎉 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

De izquierda a derecha

Con Graphviz (motor de diseño por defecto)

🎉 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

Con Smetana (motor de diseño interno)

🎉 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