UML

Universidad de San Carlos de Guatemala Facultad de Ingeniería Escuela de Ciencias y Sistemas

Curso: Introducción a La programación Plataforma: Windows

UML (Unified Modeling Language)

Descripción: El “Unified Modelling Languaje” (UML) provee a los analistas y arquitectos de sistemas que trabajan en el diseño y análisis de objetos de un lenguaje consistente para especificar, visualizar, construir y documentar los artefactos de un sistema de software, así también es útil para hacer modelos de negocios.


Índice

Introducción .................................................................................................................. 3

Ventajas .................................................................................................................... 3 Desventajas ............................................................................................................... 3

Fundamentación teórica: ............................................................................................... 4

Modelos .................................................................................................................... 4

Objetivos ...................................................................................................................... 5

Generales .................................................................................................................. 5 Específicos ................................................................................................................ 5

Historia del UML .......................................................................................................... 6

Funcionamiento ........................................................................................................ 7

Definición de Dependencias .......................................................................................... 8

UML Tools ............................................................................................................... 8 ArgoUML ................................................................................................................. 8 Aplicación ................................................................................................................. 9 Poseidon ................................................................................................................. 10 BOUML.................................................................................................................. 13

Ejemplos Prácticos ...................................................................................................... 15

Cajero automático ................................................................................................... 15 El Ascensor ............................................................................................................. 16

Conclusiones ............................................................................................................... 20

Tutorial desarrollado por: ........................................................................................ 21 Marco Antonio Pereira Girón .................................................................................. 21 2007-14786 ............................................................................................................. 21

Bibliografía ................................................................................................................. 22

Recomendaciones ....................................................................................................... 23


INTRODUCCIÓN UML (Unified Modeling Language) es un lenguaje que permite modelar, construir y documentar los elementos que forman un sistema software orientado a objetos. Actualmente es el mas estandarizado por la industria, debido a que ha sido elaborado por los autores de los tres métodos más usados de orientación a objetos: Grady Booch, Ivar Jacobson y Jim Rumbaugh. Estos autores fueron contratados por la empresa Rational Software Co. para crear una notación unificada en la que basar la construcción de sus herramientas CASE. En el proceso de creación de UML han participado, no obstante, otras empresas de gran peso en la industria como Microsoft, Hewlett-Packard, Oracle o IBM, así como grupos de analistas y desarrolladores. Entre sus principales ventajas tenemos:

UML se puede usar para modelar distintos tipos de sistemas: sistemas de software, sistemas de hardware, y organizaciones del mundo real. UML ofrece nueve diagramas en los cuales modelar sistemas.

Diagramas de Casos de Uso para modelar los procesos 'business'. Diagramas de Secuencia para modelar el paso de mensajes entre objetos. Diagramas de Colaboración para modelar interacciones entre objetos. Diagramas de Estado para modelar el comportamiento de los objetos en el sistema. Diagramas de Actividad para modelar el comportamiento de los Casos de Uso, objetos

u operaciones. Diagramas de Clases para modelar la estructura estática de las clases en el sistema. Diagramas de Objetos para modelar la estructura estática de los objetos en el sistema. Diagramas de Componentes para modelar componentes. Diagramas de Implementación para modelar la distribución del sistema.

UML es una consolidación de muchas de las notaciones y conceptos más usadas orientados a objetos.

Entre sus principales desventajas tenemos:

UML no es un método de desarrollo. No te va a decir cómo pasar del análisis al diseño y de este al código. No son una serie de pasos que te llevan a producir código a partir de unas especificaciones.

UML al no ser un método de desarrollo es independiente del ciclo de desarrollo que vayas a seguir, puede encajar en un tradicional ciclo en cascada, o en un evolutivo ciclo en espiral o incluso en los métodos ágiles de desarrollo.

Diversos desarrolladores también dan nota de que UML es algo impreciso dentro de su notación, por ejemplo, al hacer referencias a un diagrama con servidores, no se sabe si los servidores simbolizados se encuentran operativos, restringidos, pasivos…etc. Por eso se le califica de un poco “inexacto”.

Otro problema de UML es que no se presta con facilidad al diseño de sistemas distribuidos. En tales sistemas cobran importancia factores como transmisión, serialización, persistencia, etc. UML no cuenta con maneras de describir tales factores. No se puede, por ejemplo, usar UML para señalar que un objeto es persistente o remoto.


El uml se basa en Booch, OMT y OOSE:

FUNDAMENTACIÓN TEÓRICA: Modelos Un modelo representa a un sistema software desde una perspectiva específica. Al igual que la planta y el alzado de una figura en dibujo técnico nos muestran la misma figura vista desde distintos ángulos, cada modelo nos permite fijarnos en un aspecto distinto del sistema. Los modelos de UML con los que vamos a trabajar son los siguientes:

Diagrama de Estructura Estática. Diagrama de Casos de Uso. Diagrama de Secuencia. Diagrama de Colaboración. Diagrama de Estados. Diagrama de Paquetes.

Varios nuevos conceptos existen en UML, incluyendo:

Procesos y ramas de procesamiento Distribución y concurrencia Patrones y colaboración Diagramas de actividad Refinamiento (para manejar las relaciones entre los niveles de abstracción) Interfaces y componentes y Un lenguaje para restricciones Mecanismos de extensión (estereotipos, valores marcados y restricciones),


OBJETIVOS Generales

Proporcionar una notación y semánticas suficientes para poder alcanzar una gran cantidad de aspectos del modelado contemporáneo de una forma directa y económica.

Proporcionar las semánticas suficientes para alcanzar aspectos del modelado que son de esperar en un futuro, como por ejemplo aspectos relacionados con la tecnología de componentes, el cómputo distribuido, etc.

Proporcionar mecanismos de extensión de forma que proyectos concretos puedan extender el meta-modelo a un coste bajo.

Proporcionar mecanismos de extensión de forma que aproximaciones de modelado futuras podrían desarrollarse encima del UML.

Permitir el intercambio de modelos entre una gran variedad de herramientas. Proporcionar semánticas suficientes para especificar las interfaces a bibliotecas para la

compartición y el almacenamiento de componentes del modelo.

Específicos

Proporcionar a los usuarios un lenguaje de modelado visual expresivo y utilizable para el desarrollo e intercambio de modelos significativos.

Proporcionar mecanismos de extensión y especialización. Ser independiente del proceso de desarrollo y de los lenguajes de programación. Proporcionar una base formal para entender el lenguaje de modelado. Fomentar el crecimiento del mercado de las herramientas OO. Soportar conceptos de desarrollo de alto nivel como pueden ser colaboraciones,

frameworks, patterns, y componentes. Integrar las mejores prácticas utilizadas hasta el momento.


HISTORIA DEL UML

La notación UML se deriva y unifica las tres metodologías de análisis y diseño OO más extendidas:

Metodología de Grady Booch para la descripción de conjuntos de objetos y sus relaciones.

Técnica de modelado orientada a objetos de James Rumbaugh (OMT: Object-Modeling Technique).

Aproximación de Ivar Jacobson (OOSE: Object- Oriented Software Engineering) mediante la metodología de casos de uso (use case).

El desarrollo de UML comenzó a finales de 1994 cuando Grady Booch y Jim Rumbaugh de Rational Software Corporation empezaron a unificar sus métodos. A finales de 1995, Ivar Jacobson y su compa nía Objectory se incorporaron a Rational en su unificación, aportando el método OOSE.

De las tres metodologías de partida, las de Booch y Rumbaugh pueden ser descritas como centradas en objetos, ya que sus aproximaciones se enfocan hacia el modelado de los objetos que componen el sistema, su relación y colaboración. Por otro lado, la metodología de Jacobson es más centrada a usuario, ya que todo en su método se deriva de los escenarios de uso. UML se ha ido fomentando y aceptando como estándar desde el OMG, que es también el origen de CORBA, el estándar líder en la industria para la programación de objetos distribuidos. En 1997 UML 1.1 fue aprobada por la OMG convirtiéndose en la notación estándar de facto para el análisis y el diseño orientado a objetos.

UML es el primer método en publicar un meta-modelo en su propia notación, incluyendo la notación para la mayoría de la información de requisitos, análisis y diseño. Se trata pues de un meta-modelo auto-referencial (cualquier lenguaje de modelado de propósito general debería ser capaz de modelarse a sí mismo).

http://www.vico.org/ www-gris.det.uvigo.es/~avilas/UML/node7.html


Funcionamiento

Sirve para representar visualmente las reglas de creación, estructura y comportamiento de un grupo relacionado de objetos y procesos.

Para visualizar de forma eficiente la complejidad de un sistema u organización en un

reducido numero de diagramas. Para mantener mucho mas ágilmente las especificaciones ante los cambios y nuevas

actualizaciones de arquitectura.

Matricular proyectos

o Definir misión, objetivos y alcance o Elaborar modelos de referencia o Estimar los recursos o Analizar los riesgos o Establecer un plan director

Tomar decisiones

o Configurar un equipo de proyecto o Seleccionar la tecnología y estándares o Definir estrategias de subcontratación o Definir estrategia de licencias o Definir criterios de certificación

Planificar proyectos

o Plan de producción de software basado en casos de uso o Plan de pruebas de testing basado en casos de test o Plan de certificación de entregables en un ciclo de iteraciones


DEFINICIÓN DE DEPENDENCIAS Es una relación semántica entre dos elementos, en la cual un cambio a un elemento (el elemento independiente) puede afectar a la semántica del otro elemento (el dependiente). Las dependencias generalmente representan relaciones de uso que declara que un cambio en la especificación de un elemento puede afectar a otro elemento que la utiliza, pero no necesariamente a la inversa. Por ejemplo un refinamiento de un elemento de diseño a un elemento de implementación. La mayoría de las veces se utilizan en el contexto de las clases o paquetes, aunque también son habituales en la vinculación de notas. UML Tools En esta investigación fueron seleccionadas únicamente herramientas de código abierto y por lo mismo libres. Se tomo esta decisión debido a que el software libre esta aumentando su uso y calidad a un paso muy acelerado, además que con ello colaboramos a evitar el monopolio de las grandes empresas y ayudamos a los pequeños empresarios de esta área. ArgoUML (Descargar) Es una aplicación de diagramado de UML escrita en Java y publicada bajo la Licencia BSD open source. Dado que es una aplicación Java, está disponible en cualquier plataforma soportada por Java.

Nuevas Características en V0.20:

UML 1.4 - Características de extensibilidad mejoradas de UML 1.4 Diagramas de Secuencia Compatibilidad AndroMDA Calidad - Cientos de bugs han sido arreglados La mayoría de las funciones ahora soportan la selección múltiple de los elementos

del modelo Arrastrar y soltar desde el árbol de exploración al diagrama y dentro del árbol de

exploración

Otras características:

Construido en diseños críticos suministra una revisión no obstructiva del diseño y sugerencias para mejoras

interfaz de módulos Extensible Soporte de Internacionalización para Inglés, Alemán, Francés, Español y Ruso Restricciones OCL para Clases Soporte para el lenguaje de generación de Código: Java, PHP, Python, C++ y Csharp

(C#) ingeniería inversa disposición(layout) automática del diagrama de clases Generación de ficheros PNG, GIF, JPG, SVG, EPS desde diagramas Soporte para comentarios para múltiples elementos todos los diagramas 1.4 están soportados


Aplicación

Este es el aspecto de ArgoUML puro.

Una de las cosas más interesantes es que podemos exportar como XMI el trabajo realizado e importarlo en otras herramientas.


Poseidon (Descargar)

Sobre la base de ArgoUML se ha creado Poseidon

La primera de las versiones (Community Edition) es gratuita.


Este es el aspecto de poseidon.

Podemos importar muchos tipos de formatos, incluidos XMI.


La herramienta es muy creativa.


BOUML (Descargar)

Permite trabajar con UML 2 (ArgoUML todavía no lo permite). Soporta gran cantidad de diagramas (incluidos los de secuencia que en el ArgoUML

funcionan una versión si y otra no, a ver si terminan de estabilizarlo). Es rápida y apenas consume memoria. Es sencilla de utilizar. Puedes generar código para Java, C++ e IDL (y controlar bastante la generación), y

puedes hacer reingeniería inversa (a partir del código sacar el modelo). También es capaz de generar documentación en varios formatos (HTML, XMI, ...) Puedes trabajar en grupo con sus módulos "Project Control" y "Project Synchro".

Y además, aunque no es Java, también es multiplataforma: Linux, MacOS y Windows.

En definitiva, todas estas características y su bajo precio la convierten en una alternativa por lo menos digna de evaluar.

Vemos como arriba tenemos una "paleta" con los posibles elementos que podemos pintar en nuestro diagrama. Según vamos dibujamos los diferentes elementos, estos aparecen representados en el modelo de la izquierda (con doble click sobre ellos, ya sea en el modelo o en el diagrama, podemos editar sus propiedades).


El código puede generarse con esta herramienta.


EJEMPLOS PRÁCTICOS Cajero automático

Un banco necesita ayuda para modelar el sistema que hará funcionar sus nuevos cajeros automáticos portátiles. Éstos, del porte de un teléfono público, le permitirán al usuario realizar sólo las operaciones más simples: retirar, depositar y consultar saldo. Considerar que:

Se pide ingresar la clave del usuario posteriormente al paso de la tarjeta por la ranura.

No se puede retirar más fondos de los que realmente hay, notificando de esta situación al usuario.

Depositar

Retirar

ConsultarSaldo

Ingresarclave

Saldono alcanza

Clave noválida

<<uses>>

<<uses>>

<<extends>>

<<extends>>


El Ascensor Para el problema del ascensor se han dibujado los diagramas de estado y clase que se muestran a continuación. Se le pide a usted implementar el código en java. DIAGRAMA DE ESTADOS DIAGRAMA DE CLASE

Bajando a 1º Piso

Bajando

do / Ir al piso

subir(piso)

bajar(piso)

[tiempo espera]

Detenido en Piso

Subiendo

do / Ir al piso Detenido en 1º Piso

tiempo espera

subir(piso)

viajar

viajar

viajar

Ascensor direccion: boolean piso_actual mover() detener() status()

Control_Ascensor piso_id: int posición: int direccion: boolean

Puerta cerrada: boolean=true cerrar() abrir()

Boton iluminar: boolean=false iluminar() cancelar_iluminar() status()

Boton_Ascensor piso_num:int

Boton_Piso piso num: int direccion: boolean

n

m

1

1


Solución

class Ascensor{ public int direccion; public int piso_actual; public Ascensor(){ } public void mover(){ piso_actual+=direccion; } public void detener(){ direccion=0; } public int status(){ return direccion; } } class Puerta{ boolean cerrada; public Puerta(){ cerrada=true; } public void cerrar(){ cerrada=true; } public void abrir(){ cerrada=false; } } class Boton{ boolean iluminar; public Boton(){ iluminar=false; } public void iluminar(){ iluminar =true; } public void cancelar_iluminar(){ iluminar=false; } public boolean status(){ return iluminar; } } class Boton_Ascensor extends Boton{ public int piso_num; public Boton_Ascensor(int p_num){


piso_num= p_num; } } class Boton_Piso extends Boton{ public int piso_num; boolean direccion; public Boton_Piso(int p_num, boolean dir){ super(); piso_num=p_num; direccion =dir; } } class c_a{ int n= 10; long T_ultimo; Boton[] bp=new Boton_Piso[n]; Boton[] ba=new Boton_Ascensor[n]; Cola c= new Cola(); Ascensor a =new Asensor(); static public void main(String args[]){ for(int i=0;i<n;i++){ bp[i]=new Boton_Piso(i); ba[i]=new Boton_Piso(i); } while(true){ //vemos que pisos han sido apretaods y los agregamos a la cola for(int i=0;i<n;i++){ if(bp[i].status()&(bp[i].piso_num-a.piso_actual)/a.direccion=1){ cola.encolar(bp[i]); bp[i].cancelar_linuminar(); } if(ba[i].status()& (ba[i].piso_num-a.piso_actual)/a.direccion=1){ cola.encolar(bp[i]); ba[i].cancelar_linuminar(); } } if (cola.vacia() && TimeAhora()-T_ultimo< T_espera){ cola.encolar(1); direccion = -1; } //recorremos los pisos while(!cola.vacia()){ while(a.piso_actual!=c.sacar()){ a.mover() } puerta.abrir(); //se suben/bajan puerta.cerrar();


T_ultimo=TiempoAhora(); } a.detener(); } } }


CONCLUSIONES

El lenguaje Unificado de modelado UML es una notación que es el resultado de la evolución de las notaciones previas en ingeniería de software, toma los aspectos fuertes de tres metodologías anteriores: OMT, Booch y OOSE.

La notación UML se fundamenta en principios de modelado, lo cual es importante para toda implementación de un sistema de información.

El UML debe adoptar el Proceso Unificado de Desarrollo para modelar las actividades de un proyecto.

Los diagramas a utilizar en las diferentes etapas del desarrollo de los sistemas de información, pueden variar dependiendo del tamaño y tipo de sistema, por lo que es necesario organizarlos según las fases del Proceso Unificado.


Tutorial desarrollado por: Marco Antonio Pereira Girón 2007-14786


BIBLIOGRAFÍA Historia del UML

o www-gris.det.uvigo.es/~avilas/UML/node7.html o http://www.vico.org/

El “Unified Modelling Languaje” (UML)

o http://www.geocities.com/txmetsb/UML-Use-cases.htm Desarrollo Orientado a Objetos con UML C.E.C.yT. “Juan de Dios Bátíz Paredes” –

IPN UML: Toda una ventaja Andrade Castañeda Hugo Alberto TIC’s 5to”A”

Objetivos y Analisis

o http://www-gris.det.uvigo.es/~avilas/UML/node8.html ArgoUML

o http://es.wikipedia.org/wiki/ArgoUML Descarga

o http://argouml.tigris.org/v08/dc2.html Poseidon

o http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=argouml Descarga

o http://www.gentleware.com/ Bouml

o http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=bouml Descarga

o http://www.softpedia.com/progDownload/BOUML-Download-90499.html


RECOMENDACIONES Con la finalidad de dar cumplimiento al Decreto 3390, se recomienda el desarrollo del

sistema bajo herramientas de desarrollo de Software Libre.

El éxito y vida útil de los sistemas depende de la documentación antes y después de desarrollarlo, para poder adaptarlo a los requerimientos de los clientes antes de su puesta en marcha y sea fácil de migrarlo a cualquier lenguaje de programación. Esto contribuirá a realizar modificaciones y/o nuevas versiones en forma más oportuna y eficiente.

Documents

UML