2. Elementos Básicos de un Diagrama de Clases

Los diagramas de clases UML se componen de varios elementos fundamentales que permiten representar la estructura estática de un sistema. Conocer estos elementos es esencial para crear y comprender diagramas efectivos.

2.1. Clases (atributos y métodos)

La clase es el elemento central de un diagrama de clases y representa un conjunto de objetos que comparten una estructura y comportamiento comunes.

Representación gráfica de una clase

Una clase se representa como un rectángulo dividido en tres secciones:

Representación de una Clase UML

+----------------------------+
|        Nombre Clase        |
+----------------------------+
| - atributo1: tipo          |
| # atributo2: tipo          |
| + atributo3: tipo          |
+----------------------------+
| - metodo1(param): tipoRet  |
| # metodo2(param): tipoRet  |
| + metodo3(param): tipoRet  |
+----------------------------+

+ Público- Privado# Protegido~ Paquete

Tip

Las secciones de atributos y métodos pueden omitirse si no son relevantes para el diagrama. En diagramas simplificados, a veces se muestra solo el nombre de la clase.

Atributos

Los atributos son las propiedades o características que definen a una clase. Representan los datos que almacenan los objetos de esa clase.

Sintaxis

Sintaxis de Atributos en UML

[visibilidad] nombre: tipo [= valorInicial] [{propiedades}]

Donde:

• visibilidad: + (público), - (privado), # (protegido), ~ (paquete)
• nombre: identificador del atributo
• tipo: tipo de dato del atributo
• valorInicial: valor por defecto (opcional)
• propiedades: características adicionales como {readonly} (opcional)

Ejemplos

Ejemplos de Atributos en UML

- nombre: String
+ edad: Integer = 0
# saldo: Double {readonly}
- fechaNacimiento: Date
+ activo: Boolean = true

Métodos

Los métodos representan el comportamiento de una clase, es decir, las operaciones que pueden realizar los objetos de esa clase.

Sintaxis

Sintaxis de Métodos en UML

[visibilidad] nombre(parametro1: tipo1, ..., parametroN: tipoN): tipoRetorno

Donde:

• visibilidad: + (público), - (privado), # (protegido), ~ (paquete)
• nombre: identificador del método
• parametros: lista de parámetros con sus tipos (opcional)
• tipoRetorno: tipo de dato que devuelve el método

Ejemplos

Ejemplos de Métodos en UML

+ calcularEdad(): Integer
- validarDatos(usuario: String, clave: String): Boolean
# actualizarSaldo(monto: Double): void
+ obtenerInformacion(): String
- procesarPago(tarjeta: TarjetaCredito, monto: Double): Boolean

Constructores y Destructores

Los constructores y destructores son métodos especiales:

• Constructor: Se representa con el mismo nombre de la clase

  Constructor en UML

  + NombreClase(parametros): void

• Destructor: Se representa con el mismo nombre de la clase precedido por un tilde (~)

  Destructor en UML

  + ~NombreClase(): void

2.2. Objetos vs. Clases

Entender la diferencia entre clases y objetos es fundamental en el modelado orientado a objetos.

Clase

• Definición: Plantilla o plano que define atributos y comportamientos comunes
• Naturaleza: Concepto abstracto, existe en tiempo de diseño
• Representación: Rectángulo con tres secciones (nombre, atributos, métodos)
• Ejemplo: La clase “Persona” define la estructura para todas las personas
• Creación: Se define una vez en el código

Objeto

• Definición: Instancia concreta de una clase
• Naturaleza: Entidad real, existe en tiempo de ejecución
• Representación: Rectángulo con nombre subrayado (formato: nombreObjeto:NombreClase)
• Ejemplo: “juan:Persona” es un objeto específico de la clase Persona
• Creación: Se pueden crear múltiples objetos de una misma clase

Representación de objetos en UML

Aunque los objetos se representan principalmente en los diagramas de objetos, a veces aparecen en diagramas de clases para ilustrar instancias específicas:

Representación de un objeto (instancia de la clase Persona)

+------------------------+
| juan:Persona           |  (subrayado)
+------------------------+
| nombre = "Juan Pérez" |
| edad = 30              |
+------------------------+

Note

La diferencia clave entre clases y objetos es que las clases son abstracciones que definen estructura y comportamiento, mientras que los objetos son instancias concretas con valores específicos para sus atributos.

2.3. Visibilidad (público, privado, protegido)

La visibilidad define el nivel de acceso a los atributos y métodos de una clase desde otras clases del sistema.

Tipos de visibilidad

Notación

Tipos de Visibilidad en UML

  | Símbolo |   Visibilidad   |                    Descripción                     |
  |:--------:|:--------------:|:--------------------------------------------------:|
  |    +     | Público        | Accesible desde cualquier clase del sistema          |
  |    -     | Privado        | Accesible solo desde la propia clase                |
  |    #     | Protegido      | Accesible desde la propia clase y todas sus subclases |
  |    ~     | Paquete        | Accesible desde clases del mismo paquete o módulo   |

Ejemplos

Ejemplo de Visibilidad en UML

class Persona {
  + nombre: String        // Accesible desde cualquier clase
  - DNI: String          // Solo accesible dentro de Persona
  # edad: Integer        // Accesible en Persona y sus subclases
  ~ direccion: String    // Accesible en clases del mismo paquete

  + getNombre(): String  // Método público
  - validarDNI(): Boolean // Método privado
  }

Implicaciones de la visibilidad

La elección adecuada de la visibilidad es crucial para el principio de encapsulamiento en la programación orientada a objetos:

1. Visibilidad pública (+)

   • Permite acceso desde cualquier parte del sistema
   • Adecuada para interfaces y servicios que deben ser accesibles ampliamente
   • Ejemplo: métodos getter/setter, APIs públicas

2. Visibilidad privada (-)

   • Restringe el acceso solo a la propia clase
   • Oculta detalles de implementación
   • Protege la integridad de los datos
   • Ejemplo: atributos internos, métodos auxiliares

3. Visibilidad protegida (#)

   • Permite acceso desde la clase y sus subclases
   • Facilita la herencia y extensibilidad
   • Ejemplo: métodos que deben ser sobrescritos por subclases

4. Visibilidad de paquete (~)

   • Restringe el acceso a clases del mismo paquete
   • Útil para componentes que colaboran estrechamente
   • Ejemplo: clases auxiliares dentro de un mismo módulo

Caution

El uso excesivo de miembros públicos puede comprometer el encapsulamiento y hacer que el sistema sea más difícil de mantener. Es recomendable usar la visibilidad más restrictiva posible que permita el funcionamiento correcto del sistema.

Buenas prácticas de visibilidad

• Hacer los atributos privados o protegidos y proporcionar métodos públicos (getters/setters) para acceder a ellos cuando sea necesario
• Usar visibilidad protegida para métodos que deben ser sobrescritos por subclases
• Limitar la interfaz pública a lo estrictamente necesario
• Documentar claramente el propósito de los miembros públicos y protegidos