UML (Unified Modeling Language) es el lenguaje visual de modelado que permite analizar y diseñar sistemas orientados a objetos. Uno de los objetivos principales de la creación de UML es el entender, diseñar, mantener y controlar la información sobre los sistemas a construir.

Este libro proporciona una guía indispensable y práctica en el complejo proceso de definir y organizar los elementos que configuran la arquitectura de un sistema utilizando UML. Contiene una gran variedad de técnicas prácticas y potentes para el análisis y diseño de objetos, así como la sintaxis y semántica de este lenguaje de programación, de gran utilidad que se puede aplicar desde el primer momento.

Dirigido tanto a estudiantes de universidad como a analistas y diseñadores experimentados que necesitan un manual de referencia para aprender a visualizar, especificar, construir y documentar un sistema de software, esta obra se considera una lectura obligada para todos los que empiezan con UML 2.

Ahorra Con Agapea
"Compra "UML 2" junto a "Hipatia de Alejandría":

Por solo 69.7 € Gastos de envío gratis^**

Introducción
Sobre este libro
Convenciones
Quién debería leer este libro
Cómo leer este libro
Pista rápida
Referencia
Revisión
Inmersión
Ruta del libro

Parte 1. Introducción de UML y UP

1. ¿Qué es UML?
1.1. Presentación del capítulo
1.2. ¿Qué es UML?
1.3. El nacimiento de UML
1.4. MDA, el futuro de UML
1.5. ¿Por qué 'unificado'?
1.6. Objetos y UML
1.7. Estructura de UML
1.8. Bloques de construcción de UML
1.8.1. Elementos
1.8.2. Relaciones
1.8.3. Diagramas
1.9. Mecanismos comunes de UML
1.9.1. Especificaciones
1.9.2. Adornos
1.9.3. Divisiones comunes
1.9.3.1. Clasificador e instancia
1.9.3.2. Interfaz e implementación
1.9.4. Mecanismos de extensibilidad
1.9.4.1. Restricciones
1.9.4.2. Estereotipos
1.9.4.3. Valores etiquetados
1.9.4.4. Perfiles UML
1.10. Arquitectura
1.11. ¿Qué hemos aprendido?

2. ¿Qué es el proceso unificado?
2.1. Presentación del capítulo
2.2. ¿Qué es UP?
2.3. El nacimiento de UP
2.4. UP y el Proceso Racional Unificado
2.5. Instanciar UP para su proyecto
2.6. Axiomas de UP
2.7. UP es un proceso iterativo e incremental
2.7.1. Workflows de iteración
2.7.2. Líneas base e incrementos
2.8. Estructura de UP
2.9. Fases de UP
2.9.1. Comienzo: objetivos
2.9.2. Comienzo: foco
2.9.3. Comienzo: hito. Objetivos del ciclo de vida
2.9.4. Elaboración: objetivos
2.9.5. Elaboración: foco
2.9.6. Elaboración: hito. Arquitectura del ciclo de vida
2.9.7. Construcción: objetivos
2.9.8. Construcción: foco
2.9.9. Construcción: hito. Capacidad operativa inicial
2.9.10. Transición: objetivos
2.9.11. Transición: foco
2.9.12. Transición: hito. Versión del producto
2.10. ¿Qué hemos aprendido?

Parte 2. Requisitos

3. El workflow de requisitos
3.1. Presentación del capítulo
3.2. El workflow de requisitos
3.3. Requisitos de software: metamodelo
3.4. Detalle del workflow de requisitos
3.5. La importancia de los requisitos
3.6. Definir requisitos
3.6.1. El modelo de requisitos
3.6.2. Requisitos bien formados
3.6.3. Requisitos funcionales y no funcionales
3.6.4. Organizar requisitos
3.6.5. Atributos de requisitos
3.7. Encontrar requisitos
3.7.1. Obtención de requisitos: el mapa no es el territorio
3.7.2. Entrevistas
3.7.3. Cuestionarios
3.7.4. Workshop de requisitos
3.8. ¿Qué hemos aprendido?

4. Modelado del caso de uso
4.1. Presentación del capítulo
4.2. Modelado de caso de uso
4.3. Actividad UP: encontrar actores y casos de uso
4.3.1. El sujeto (límite del sistema)
4.3.2. ¿Qué son actores?
4.3.2.1. Identificar actores
4.3.2.2. Tiempo como un actor
4.3.3. ¿Qué son casos de uso?
4.3.3.1. Identificar casos de uso
4.3.3.2. El diagrama de caso de uso
4.3.4. El glosario del proyecto
4.4. Actividad UP: Detallar un caso de uso
4.5. Especificación de caso de uso
4.5.1. Nombre del caso de uso
4.5.2. ID de caso de uso
4.5.3. Breve descripción
4.5.4. Actores
4.5.5. Precondiciones y poscondiciones
4.5.6. Flujo principal
4.5.6.1. Ramificación dentro de un flujo
4.5.6.2. Palabra clave Si
4.5.6.3. Repetición dentro de un flujo
4.5.6.4. Palabra clave Para
4.5.6.5. Palabra clave Mientras
4.5.7. Modelar flujos alternativos
4.5.7.1. Encontrar flujos alternativos
4.5.7.2. ¿Cuántos flujos alternativos?
4.6. Seguimiento de requisitos
4.7. ¿Cuándo aplicar modelado de caso de uso?
4.8. ¿Qué hemos aprendido?

5. Modelado avanzado de caso de uso
5.1. Presentación del capítulo
5.2. Generalización de actor
5.3. Generalización de caso de uso
5.4. <>
5.5. <>
5.5.1. El caso de uso de extensión
5.5.2. Múltiples segmentos de inserción
5.5.3. Extensiones condicionales
5.6. Cuándo utilizar características avanzadas
5.7. Sugerencias para escribir casos de uso
5.7.1. Mantener los casos de uso breves y sencillos
5.7.2. Centrarse en el qué, no en el cómo
5.7.3. Evite descomposición funcional
5.8. ¿Qué hemos aprendido?

Parte 3. Análisis

6. El workflow de análisis
6.1. Presentación del capítulo
6.2. El workflow de análisis
6.3. Artefactos de análisis - metamodelo
6.4. Detalle del workflow de análisis
6.5. Modelo de análisis - reglas generales
6.6. ¿Qué hemos aprendido?

7. Objetos y clases
7.1. Presentación del capítulo
7.2. ¿Qué son objetos?
7.2.1. Encapsulación
7.2.2. Mensajería
7.3. Notación de objeto UML
7.3.1. Valores de atributo de objeto
7.4. ¿Qué son clases?
7.4.1. Clases y objetos
7.4.2. Instanciar clases
7.5. Notación de clase de UML
7.5.1. Compartimiento de nombre
7.5.2. Compartimiento de atributo
7.5.2.1. Visibilidad
7.5.2.2. Tipo
7.5.2.3. Multiplicidad
7.5.2.4. Valor inicial
7.5.2.5. Sintaxis avanzada de atributo
7.5.3. Compartimiento de operación
7.5.3.1. Dirección del parámetro
7.5.3.2. Valores por defecto de parámetros
7.5.3.3. Sintaxis avanzada de operación
7.5.3.4. Operaciones de consulta
7.5.4. Sintaxis de estereotipo de clase
7.6. Ámbito de aplicación
7.6.1. Ámbito de instancia y ámbito de clase
7.6.2. El ámbito determina el acceso
7.7. Construcción y destrucción de objetos
7.7.1. Constructores: ejemplo de clase SocioClub
7.7.2. Destructores: ejemplo de clase SocioClub
7.8. ¿Qué hemos aprendido?

8. Encontrar clases de análisis
8.1. Presentación del capítulo
8.2. Actividad UP. Analizar un caso de uso
8.3. ¿Qué son clases de análisis?
8.3.1. Anatomía de una clase de análisis
8.3.2. ¿Qué hace una buena clase de análisis?
8.3.3. Reglas generales de clases de análisis
8.4. Encontrar clases
8.4.1. Encontrar clases al utilizar análisis nombre/verbo
8.4.1.1. Procedimiento de análisis nombre/verbo
8.4.2. Encontrar clases al utilizar análisis CRC
8.4.2.1. Procedimiento de análisis CRC
8.4.2.2. Fase 1. Tormenta de ideas: recopilar información
8.4.2.3. Fase 2. Analizar información
8.4.3. Encontrar clases al utilizar los estereotipos RUP
8.4.3.1. Encontrar clases <>
8.4.3.2. Encontrar clases <>
8.4.3.3. Encontrar clases <>
8.4.4. Encontrar clases de otras fuentes
8.4.4.1. Patrones arquetipo
8.5. Crear un modelo de análisis de primer nivel
8.6. ¿Qué hemos aprendido?

9. Relaciones
9.1. Presentación del capítulo
9.2. ¿Qué es una relación?
9.3. ¿Qué es un vínculo?
9.3.1. Diagramas de objeto
9.3.2. Rutas de acceso
9.4. ¿Qué es una asociación?
9.4.1. Sintaxis de asociación
9.4.2. Multiplicidad
9.4.2.1. Asociaciones reflexivas
9.4.2.2. Jerarquías y redes
9.4.3. Navegabilidad
9.4.4. Asociaciones y atributos
9.4.5. Clases de asociación
9.4.6. Asociaciones cualificadas
9.5. ¿Qué es una dependencia?
9.5.1. Dependencias de uso
9.5.1.1. <>
9.5.1.2. <>
9.5.1.3. < >
9.5.1.4. <>
9.5.1.5. <>
9.5.2. Dependencias de abstracción
9.5.2.1. <>
9.5.2.2. <>
9.5.2.3. <>
9.5.2.4. <>
9.5.3. Dependencias de permiso
9.5.3.1. <>
9.5.3.2. <>
9.5.3.3. <>
9.6. ¿Qué hemos aprendido?

10. Herencia y polimorfismo
10.1. Presentación del capítulo
10.2. Generalización
10.2.1. Generalización de clase
10.3. Herencia de clase
10.3.1. Anular
10.3.2. Operaciones y clases abstractas
10.3.3. Nivel de abstracción
10.3.4. Herencia múltiple
10.4. Polimorfismo
10.4.1. Ejemplo de polimorfismo
10.5. Generalización avanzada
10.5.1. Conjuntos de generalización
10.5.2. Powertypes
10.6. ¿Qué hemos aprendido?

11. Paquetes de análisis
11.1. Presentación del capítulo
11.2. ¿Qué es un paquete?
11.3. Paquetes y espacios de nombres
11.4. Paquetes anidados
11.5. Dependencias de paquete
11.5.1. Transitividad
11.6. Generalización de paquete
11.7. Análisis de arquitectura
11.7.1. Encontrar paquetes de análisis
11.7.2. Dependencias cíclicas de paquete
11.8. ¿Qué hemos aprendido?

12. Realización de casos de uso
12.1. Presentación del capítulo
12.2. Actividad UP: Analizar un caso de uso
12.3. ¿Qué son las realizaciones de caso de uso?
12.4. Realización de caso de uso: elementos
12.5. Interacciones
12.6. Líneas de vida
12.7. Mensajes
12.7.1. Mensajes síncronos, asíncronos y de retorno
12.7.2. Mensajes de creación y destrucción
12.7.3. Mensajes encontrados y perdidos
12.8. Diagramas de interacción
12.9. Diagramas de secuencia
12.9.1. Líneas de vida y mensajes
12.9.2. Activaciones
12.9.3. Documentar diagramas de secuencia
12.9.4. Invariantes de estado y restricciones
12.10. Fragmentos combinados y operadores
12.10.1. Ramificación con opt y alt
12.10.2. Iteración con loop y break
12.11. Diagramas de comunicación
12.11.1. Iteración
12.11.2. Ramificación
12.12. ¿Qué hemos aprendido?

13. Realización avanzada del caso de uso
13.1. Presentación del capítulo
13.2. Ocurrencias de interacción
13.2.1. Parámetros
13.2.2. Puertas
13.3. Continuaciones
13.4. ¿Qué hemos aprendido?

14. Diagramas de actividad
14.1. Presentación del capítulo
14.2. ¿Qué son diagramas de actividad?
14.3. Diagramas de actividad y UP
14.4. Actividades
14.5. Semántica de actividad
14.6. Particiones de actividad
14.7. Nodos de acción
14.7.1. Nodo de acción de llamada
14.7.2. Nodo de acción de aceptar evento de tiempo
14.8. Nodos de control
14.8.1. Nodo inicial y nodos finales
14.8.2. Nodos de decisión y nodos de fusión
14.8.3. Nodos fork y join, concurrencia
14.9. Nodos de objeto
14.9.1. Semántica del buffer del nodo de objeto
14.9.2. Representar objetos en estado
14.9.3. Parámetros de actividad
14.10. Pins
14.11. ¿Qué hemos aprendido?

15. Diagramas avanzados de actividad
15.1. Presentación del capítulo
15.2. Conectores
15.3. Regiones interrumpibles de actividad
15.4. Gestión de excepciones
15.5. Nodos de expansión
15.6. Enviar señales y aceptar eventos
15.7. Streaming
15.8. Características avanzadas de flujo de objeto
15.8.1. Efectos de entrada y efectos de salida
15.8.2. < >
15.8.3. <>
15.9. Multidifusión y multireceptor
15.10. Conjuntos de parámetros
15.11. Nodo <>
15.12. Diagramas de visión de interacción
15.13. ¿Qué hemos aprendido?

Parte 4. Diseño

16. Workflow de diseño
16.1. Presentación del capítulo
16.2. El workflow de diseño
16.3. Diseñar artefactos: metamodelo
16.3.1. Relaciones de seguimiento de artefactos
16.3.2. ¿Debería mantener dos modelos?
16.4. Detalle del workflow de diseño
16.5. Actividad UP: diseño de arquitectura
16.6. ¿Qué hemos aprendido?

17. Diseñar clases
17.1. Presentación del capítulo
17.2. Actividad UP: Diseñar una clase
17.3. ¿Qué son clases de diseño?
17.4. Anatomía de una clase de diseño
17.5. Clases de diseño bien creadas
17.5.1. Totalidad y suficiencia
17.5.2. Sencillez
17.5.3. Alta cohesión
17.5.4. Bajo acoplamiento
17.6. Herencia
17.6.1. Agregación vs. herencia
17.6.2. Herencia múltiple
17.6.3. Herencia vs. realización de interfaz
17.7. Plantillas
17.8. Clases anidadas
17.9. ¿Qué hemos aprendido?

18. Mejorar relaciones de análisis
18.1. Presentación del capítulo
18.2. Diseñar relaciones
18.3. Agregación y composición
18.4. Semántica de agregación
18.5. Semántica de composición
18.5.1. Composición y atributos
18.6. Cómo mejorar relaciones de análisis
18.7. Asociaciones uno a uno
18.8. Asociaciones muchos a uno
18.9. Asociaciones uno a muchos
18.10. Colecciones
18.10.1. El mapa
18.11. Relaciones cosificadas
18.11.1. Asociaciones muchos a muchos
18.11.2. Asociaciones bidireccionales
18.11.3. Clases de asociación
18.12. Explorar composición con clases estructuradas
18.12.1. Clasificadores estructurados
18.12.2. Clases estructuradas
18.13. ¿Qué hemos aprendido?

19. Interfaces y componentes
19.1. Presentación del capítulo
19.2. Actividad UP: Diseñar un subsistema
19.3. ¿Qué es una interfaz?
19.4. Interfaces proporcionadas y requeridas
19.5. Realización de interfaz vs. herencia
19.6. Puertos
19.7. Interfaces y desarrollo basado en componentes
19.8. ¿Qué es un componente?
19.9. Estereotipos de componente
19.10. Subsistemas
19.11. Encontrar interfaces
19.12. Diseñar con interfaces
19.12.1. El patrón Fachada
19.12.2. Arquitectura y el patrón de disposición en capas
19.13. Ventajas y desventajas de las interfaces
19.14. ¿Qué hemos aprendido?

20. Realización de caso de uso: diseño
20.1. Presentación del capítulo
20.2. Actividad UP: Diseñar un caso de uso
20.3. Realización de caso de uso: diseño
20.4. Diagramas de interacción en diseño
20.5. Modelar concurrencia
20.5.1. Clases activas
20.5.2. Concurrencia en diagramas de secuencia
20.5.3. Concurrencia en diagramas de comunicación
20.6. Interacciones de subsistema
20.7. Diagramas de tiempo
20.8. Ejemplo de realización de caso de uso: diseño
20.9. ¿Qué hemos aprendido?

21. Máquinas de estado
21.1. Presentación del capítulo
21.2. Máquinas de estado
21.2.1. Máquinas de estado de comportamiento y máquinas de estadode protocolo
21.2.2. Máquinas de estado y clases
21.3. Máquinas de estado y el UP
21.4. Diagramas de máquina de estado
21.5. Estados
21.5.1. Sintaxis de estado
21.6. Transiciones
21.6.1. Conectar transiciones, el pseudo estado de unión
21.6.2. Ramificar transiciones, el pseudo estado de opción
21.7. Eventos
21.7.1. Evento de llamada
21.7.2. Eventos de señal
21.7.3. Eventos de cambio
21.7.4. Eventos de tiempo
21.8. ¿Qué hemos aprendido?

22. Máquinas de estado avanzadas
22.1. Presentación del capítulo
22.2. Estados compuestos
22.2.1. Estados compuestos sencillos
22.2.2. Estados compuestos ortogonales
22.3. Estados de submáquina
22.4. Comunicación de submáquina
22.5. Historia
22.5.1. Historia superficial
22.5.2. Historia profunda
22.6. ¿Qué hemos aprendido?

Parte 5. Implementación

23. El workflow de implementación
23.1. Presentación del capítulo
23.2. El workflow de implementación
23.3. Artefactos de implementación: metamodelo
23.4. Detalle del workflow de implementación
23.5. Artefactos
23.6. ¿Qué hemos aprendido?

24. Despliegue
24.1. Presentación del capítulo
24.2. Actividad UP: Implementación de arquitectura
24.3. El diagrama de despliegue
24.4. Nodos
24.5. Artefactos
24.6. Despliegue
24.7. ¿Qué hemos aprendido?

Parte 6. Material adicional

25. Introducción a OCL
25.1. Presentación del capítulo
25.2. ¿Qué es el Lenguaje de Restricción de Objetos (OCL)?
25.3. ¿Por qué utilizar OCL?
25.4. Sintaxis de expresión OCL
25.5. Contexto de paquete y nombres de ruta
25.6. El contexto de expresión
25.7. Tipos de expresiones OCL
25.8. El cuerpo de expresión
25.8.1. Comentarios, palabras clave y reglas de precedencia
25.8.2. El sistema de tipo de OCL
25.8.3. Tipos primitivos
25.8.3.1. Boolean
25.8.3.2. Integer y Real
25.8.3.3. String
25.8.4. Tuples
25.8.5. Operadores infijos
25.8.6. Colecciones OCL
25.8.6.1. Operaciones de colección
25.8.6.2. Operaciones de conversión
25.8.6.3. Operaciones de comparación
25.8.6.4. Operaciones de consulta
25.8.6.5. Operaciones de acceso
25.8.6.6. Operaciones de selección
25.8.7. Operaciones de iteración
25.8.7.1. Operación iterate
25.9. Navegación OCL
25.9.1. Navegación dentro de la instancia contextual
25.9.2. Navegación a través de asociaciones
25.9.3. Navegación a través de múltiples asociaciones
25.10. Tipos de expresión OCL en detalle
25.10.1. inv:
25.10.2. pre:, post: y @pre
25.10.3. body:
25.10.4. init:
25.10.5. def:
25.10.6. Expresiones let
25.10.7. derive:
25.11. OCL en otros tipos de diagramas
25.11.1. OCL en diagramas de interacción
25.11.2. OCL en diagramas de actividad
25.11.3. OCL en máquinas de estado
25.12. Temas avanzados
25.12.1. Navegación a y desde clases de asociación
25.12.2. Navegación por asociaciones cualificadas
25.12.3. Asociaciones heredadas
25.12.4. OclMessage
25.13. ¿Qué hemos aprendido?

Apéndice 1. Modelo de caso de uso de ejemplo
A1.1. Introducción
A1.2. Modelo de caso de uso
A1.3. Casos de uso de ejemplo

Apéndice 2. XML y casos de uso
A2.1. Utilizar XML para plantillas de casos de uso
A2.2. SUMR

Bibliografía

Índice alfabético