Puede contribuir en esta página haciendo clic aquí (Menu)
English
Deutsch
Español
Français
日本語
한국어
Русский
中文

You can vote to improve syntax about packages/namespaces !

Diagrama de Clases

Relación entre clases

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:

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

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

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

Etiquetas en las relaciones

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.

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

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

@startuml
Object <|-- ArrayList

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

@enduml

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 :

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

@enduml

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

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




<s>, <del>, <strike>
 or 
<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

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.

@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

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

@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

Uso de clases genéricas

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.

@startuml

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

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

@enduml

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.

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

@startuml

skinparam packageStyle rectangle

package foo1.foo2 {
}

package foo1.foo2.foo3 {
  class Object
}

foo1.foo2 +-- foo1.foo2.foo3

@enduml

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.

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

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

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

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.

@startuml

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

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

Class03 o-- Class04 : aggregation

@enduml

Estereotipos personalizados

Puedes definir colores y fuentes específicas para clases esterotipadas.

@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

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:

@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

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

Type	Symbol	Drawing
Extension	`<\|--`
Composition	`*--`
Aggregation	`o--`

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