DISEÑO DE LA LOGICA

El diseño lógico es el proceso de construir un esquema de la información que utiliza la empresa, basándose en un modelo de base de datos específico, independiente del SGBD (Sistema de Gestión de Base de Datos) concreto que se vaya a utilizar y de cualquier otra consideración física.

En esta etapa, se transforma el esquema conceptual en un esquema lógico que utilizará las estructuras de datos del modelo de base de datos en el que se basa el SGBD que se vaya a utilizar, como puede ser el modelo relacional, el modelo de red, el modelo jerárquico o el modelo orientado a objetos. Conforme se va desarrollando el esquema lógico, éste se va probando y validando con los requisitos de usuario.

La normalización es una técnica que se utiliza para comprobar la validez de los esquemas lógicos basados en el modelo relacional, ya que asegura que las relaciones (tablas) obtenidas no tienen datos redundantes. Esta técnica se presenta en el capítulo dedicado al diseño lógico de bases de datos.

El esquema lógico es una fuente de información para el diseño físico. Además, juega un papel importante durante la etapa de mantenimiento del sistema, ya que permite que los futuros cambios que se realicen sobre los programas de aplicación o sobre los datos, se representen correctamente en la base de datos.

Tanto el diseño conceptual, como el diseño lógico, son procesos iterativos, tienen un punto de inicio y se van refinando continuamente. Ambos se deben ver como un proceso de aprendizaje en el que el diseñador va comprendiendo el funcionamiento de la empresa y el significado de los datos que maneja. El diseño conceptual y el diseño lógico son etapas clave para conseguir un sistema que funcione correctamente. Si el esquema no es una representación fiel de la empresa, será difícil, sino imposible, definir todas las vistas de usuario (esquemas externos), o mantener la integridad de la base de datos. También puede ser difícil definir la implementación física o el mantener unas prestaciones aceptables del sistema. Además, hay que tener en cuenta que la capacidad de ajustarse a futuros cambios es un sello que identifica a los buenos diseños de bases de datos. Por todo esto, es fundamental dedicar el tiempo y las energías necesarias para producir el mejor esquema que sea posible.

CLASES Y OBJETOS

Para crear una clase se utiliza la palabra reservada class y a continuación el nombre de la clase. La definición de la clase se pone entre las llaves de apertura y cierre. El nombre de la clase empieza por letra mayúscula.

class Rectangulo{ //miembros dato //funciones miembro }

Los miembros dato

Los valores de los atributos se guardan en los miembros dato o variables de instancia. Los nombres de dichas variables comienzan por letra minúscula.

Vamos a crear una clase denominada Rectangulo, que describa las características comunes a estas figuras planas que son las siguientes:

El origen del rectángulo: el origen o posición de la esquina superior izquierda del rectángulo en el plano determinado por dos números enteros x e y. Las dimensiones del rectángulo: ancho y alto, otros dos números enteros.

class Rectangulo{ int x; int y; int ancho; int alto; //faltan las funciones miembro }

Las funciones miembro

En el lenguaje C++ la función miembro se declara, se define y se llaman. En el lenguaje Java la función miembro o métodos solamente se definen y se llaman.

El nombre de las funciones miembro o métodos comienza por letra minúscula y deben sugerir acciones (mover, calcular, etc.). La definición de una función tiene el siguiente formato:

tipo nombreFuncion(tipo parm1, tipo parm2, tipo parm3){ //…sentencias } Entre las llaves de apertura y cierre se coloca la definición de la función. tipo indica el tipo de dato que puede ser predefinido int, double, etc, o definido por el usuario, una clase cualquiera.

Para llamar a un función miembro o método se escribe retorno=objeto.nombreFuncion(arg1, arg2, arg3); Cuando se llama a la función, los argumentos arg1, arg2, arg3 se copian en los parámetros parm1, parm2, parm3 y se ejecutan las sentencias dentro de la función. La función finaliza cuando se llega al final de su bloque de definición o cuando encuentra una sentencia return.

Cuando se llama a la función, el valor devuelto mediante la sentencia return se asigna a la variable retorno.

Cuando una función no devuelve nada se dice de tipo void. Para llamar a la función, se escribe objeto.nombreFuncion(arg1, arg2, arg3); Estudiaremos más adelante con más detalle como se definen las funciones.

Una función suele finalizar cuando llega al final del bloque de su definición

void funcion(….){ //sentencias… } Una función puede finalizar antes del llegar al final de su definición

void funcion(….){ //sentencias… if(condicion) return; //sentencias.. } Una función puede devolver un valor (un tipo de dato primitivo o un objeto). double funcion(….){ double suma=0.0; //sentencias… return suma; } Cualquier variable declarada dentro de la función tiene una vida temporal, existiendo en memoria, mientras la función esté activa. Se trata de variables locales a la función. Por ejemplo:

void nombreFuncion(int parm){ //… int i=5; //… } La variable parm, existe desde el comienzo hasta el final de la función. La variable local i, existe desde el punto de su declaración hasta el final del bloque de la función.

Se ha de tener en cuenta que las funciones miembro tienen acceso a los miembros dato, por tanto, es importante en el diseño de una clase decidir qué variables son miembros dato, qué variables son locales a las funciones miembro, y qué valores les pasamos a dichas funciones. Los ejemplos nos ayudarán a entender esta distinción.

Hemos definido los atributos o miembros dato de la clase Rectangulo, ahora le vamos añadir un comportamiento: los objetos de la clase Rectangulo o rectángulos sabrán calcular su área, tendrán capacidad para trasladarse a otro punto del plano, sabrán si contienen en su interior un punto determinado del plano.

La función que calcula el área realizará la siguiente tarea, calculará el producto del ancho por el alto del rectángulo y devolverá el resultado. La función devuelve un entero es por tanto, de tipo int. No es necesario pasarle datos ya que tiene acceso a los miembros dato ancho y alto que guardan la anchura y la altura de un rectángulo concreto.

class Rectangulo{ int x; int y; int ancho; int alto; int calcularArea(){ return (ancho*alto); } }

A la función que desplaza el rectángulo horizontalmente en dx, y verticalmente en dy, le pasamos dichos desplazamientos, y a partir de estos datos actualizará los valores que guardan sus miembros dato x e y. La función no devuelve nada es de tipo void.

class Rectangulo{ int x; int y; int ancho; int alto; void desplazar(int dx, int dy){ x+=dx; y+=dy; } } La función que determina si un punto está o no en el interior del rectángulo, devolverá true si el punto se encuentra en el interior del rectángulo y devolverá false si no se encuentra, es decir, será una función del tipo boolean. La función necesitará conocer las coordenadas de dicho punto. Para que un punto de coordenadas x1 e y1 esté dentro de un rectángulo cuyo origen es x e y, y cuyas dimensiones son ancho y alto, se deberá cumplir a la vez cuatro condiciones

x1>x y a la vez x1<x+ancho

También se debe cumplir

y1>y y a la vez y1<y+alto

Como se tienen que cumplir las cuatro condiciones a la vez, se unen mediante el operador lógico AND simbolizado por &&.

class Rectangulo{ int x; int y; int ancho; int alto; boolean estaDentro(int x1, int y1){ if((x1>x)&&(x1<x+ancho)&&(y1>y)&&(y1<y+ancho)){ return true; } return false; } } En el lenguaje Java, si la primera condición es falsa no se evalúan las restantes expresiones ya que el resultado es false. Ahora bien, si la primera es verdadera true, se pasa a evaluar la segunda, si ésta el falsa el resultado es false, y así sucesivamente.

Los contructores

Un objeto de una clase se crea llamando a una función especial denominada constructor de la clase. El constructor se llama de forma automática cuando se crea un objeto, para situarlo en memoria e inicializar los miembros datos declarados en la clase. El constructor tiene el mismo nombre que la clase. Lo específico del constructor es que no tiene tipo de retorno.

class Rectangulo{ int x; int y; int ancho; int alto; Rectangulo(int x1, int y1, int w, int h){ x=x1; y=y1; ancho=w; alto=h; } } El constructor recibe cuatro números que guardan los parámetros x1, y1, w y h, y con ellos inicializa los miembros dato x, y, ancho y alto.

Una clase puede tener más de un constructor. Por ejemplo, el siguiente constructor crea un rectángulo cuyo origen está en el punto (0, 0).

class Rectangulo{ int x; int y; int ancho; int alto; Rectangulo(int w, int h){ x=0; y=0; ancho=w; alto=h; } } Este constructor crea un rectángulo de dimensiones nulas situado en el punto (0, 0),

class Rectangulo{ int x; int y; int ancho; int alto; Rectangulo(){ x=0; y=0; ancho=0;

alto=0; } }

Con estas porciones de código definimos la clase, y la guardamos en un archivo que tenga el mismo nombre que la clase Rectangulo y con extensión .java.

public class Rectangulo { int x; int y; int ancho; int alto; public Rectangulo() { x=0; y=0; ancho=0; alto=0; } public Rectangulo(int x1, int y1, int w, int h) { x=x1; y=y1; ancho=w; alto=h; } public Rectangulo(int w, int h) { x=0; y=0; ancho=w; alto=h; } int calcularArea(){ return (ancho*alto); } void desplazar(int dx, int dy){ x+=dx; y+=dy; } boolean estaDentro(int x1, int y1){ if((x1>x)&&(x1<x+ancho)&&(y1>y)&&(y1<y+ancho)){ return true; } return false; } }

Los objetos

Para crear un objeto de una clase se usa la palabra reservada new.

Por ejemplo,

Rectangulo rect1=new Rectangulo(10, 20, 40, 80);

new reserva espacio en memoria para los miembros dato y devuelve una referencia que se guarda en la variable rect1 del tipo Rectangulo que denominamos ahora objeto. Dicha sentencia, crea un objeto denominado rect1 de la clase Rectangulo llamando al segundo constructor en el listado. El rectángulo estará situado en el punto de coordenadas x=10, y=20; tendrá una anchura de ancho=40 y una altura de alto=80. Rectangulo rect2=new Rectangulo(40, 80); Crea un objeto denominado rect2 de la clase Rectangulo llamando al tercer constructor, dicho rectángulo estará situado en el punto de coordenadas x=0, y=0; y tendrá una anchura de ancho=40 y una altura de alto=80. Rectangulo rect3=new Rectangulo(); Crea un objeto denominado rect3 de la clase Rectangulo llamando al primer constructor, dicho rectángulo estará situado en el punto de coordenadas x=0, y=0; y tendrá una anchura de ancho=0 y una altura de alto=0.

Acceso a los miembros

Desde un objeto se puede acceder a los miembros mediante la siguiente sintaxis objeto.miembro;

Por ejemplo, podemos acceder al miembro dato ancho, para cambiar la anchura de un objeto rectángulo. rect1.ancho=100; El rectángulo rect1 que tenía inicialmente una anchura de 40, mediante esta sentencia se la cambiamos a 100.

Desde un objeto llamamos a las funciones miembro para realizar una determinada tarea. Por ejemplo, desde el rectángulo rect1 llamamos a la función calcularArea para calcular el área de dicho rectángulo. rect1.calcularArea(); La función miembro area devuelve un entero, que guardaremos en una variable entera medidaArea, para luego usar este dato. int medidaArea=rect1.calcularArea(); System.out.println(“El área del rectángulo es “+medidaArea); Para desplazar el rectángulo rect2, 10 unidades hacia la derecha y 20 hacia abajo, escribiremos rect2.desplazar(10, 20); Podemos verificar mediante el siguiente código si el punto (20, 30) está en el interior del rectángulo rect1. if(rect1.estaDentro(20,30)){ System.out.println(“El punto está dentro del rectángulo”); }else{ System.out.println(“El punto está fuera del rectángulo”);

} rect1.dentro() devuelve true si el punto (20, 30) que se le pasa a dicha función miembro está en el interior del rectángulo rect1, ejecutándose la primera sentencia, en caso contrario se ejecuta la segunda.

Como veremos más adelante no siempre es posible acceder a los miembros, si establecemos controles de acceso a los mismos.

public class Rectangulo App 1? { public static void main(String[] args) { Rectangulo rect1=new Rectangulo(10, 20, 40, 80); Rectangulo rect2=new Rectangulo(40, 80); Rectangulo rect3=new Rectangulo(); int medidaArea=rect1.calcularArea(); System.out.println(“El área del rectángulo es “+medidaArea); rect2.desplazar(10, 20); if(rect1.estaDentro(20,30)){ System.out.println(“El punto está dentro del rectángulo”); }else{ System.out.println(“El punto está fuera del rectángulo”); } } }

La vida de un objeto

En el lenguaje C++, los objetos que se crean con new se han de eliminar con delete. new reserva espacio en memoria para el objeto y delete libera dicha memoria. En el lenguaje Java no es necesario liberar la memoria reservada, el recolector de basura (garbage collector) se encarga de hacerlo por nosotros, liberando al programador de una de las tareas que más quebraderos de cabeza le producen, olvidarse de liberar la memoria reservada.

Veamos un ejemplo

public class Una Clase? { public static void main(String[] args) { Image granImagen=creaImagen(); mostrar(graImagen); while(condicion){ calcular(); } } }

El objeto granImagen, continua en memoria hasta que se alcanza el final de la función main, aunque solamente es necesario hasta el bucle while. En C o en C++ eliminariamos dicho objeto liberando la memoria que ocupa mediante delete. El equivalente en Java es el de asignar al objeto granImagen el valor null.

public class Una Clase { public static void main(String[] args) { Image granImagen=creaImagen(); mostrar(graImagen); granImagen=null; while(condicion){ calcular(); } } }

A partir de la sentencia marcada en letra negrita el recolector de basura se encargará de liberar la memoria ocupada por dicha imagen. Así pues, se asignará el valor null a las referencias a objetos temporales que ocupen mucha memoria tan pronto como no sean necesarios.

Creamos dos objetos de la clase rectángulo, del mismo modo que en el apartado anterior Rectangulo rect1=new Rectangulo(10, 20, 40, 80); Rectangulo rect3=new Rectangulo(); Si escribimos rect3=rect1; En rect3 se guarda la referencia al objeto rect1. La referencia al objeto rect3 se pierde. El recolector se encarga de liberar el espacio en memoria ocupado por el objeto rect3.

La destrucción de un objeto es una tarea (thread) de baja prioridad que lleva a cabo la Máquina Virtual Java (JVM). Por tanto, nunca podemos saber cuándo se va a destruir un objeto.

Puede haber situaciones en las que es necesario realizar ciertas operaciones que no puede realizar el recolector de basura (garbage collector) cuando se destruye un objeto. Por ejemplo, se han abierto varios archivos durante la vida de un objeto, y se desea que los archivos estén cerrados cuando dicho objeto desaparece. Se puede definir en la clase un método denominado finalicé que realice esta tarea. Este método es llamado por el recolector de basura inmediatamente antes de que el objeto sea destruído.

ESTADOS Y TRANSICIONES

MODELADO DEL COMPORTAMIENTO EN LOS DIAGRAMASDE ESTADO Eventos, estados y transiciones Evento: es un acontecimiento importante o digno de señalar. (Levantar el auricular telefónico.)

Estado: es la condición de un objeto en un momento determinado: el tiempo que transcurre entre eventos. (Un teléfono se encuentra en estado “ocioso“una vez que el auricular es puesto en su sitio y mientras no lo levantemos.) Transición: es una relación entre dos estados, indica que, cuando ocurre un evento el objeto pasa del estado anterior al siguiente. (Cuando ocurre el evento “levantar el auricular“, el teléfono realiza la transición el estado “ocioso“al estado “activo“.)

DIAGRAMAS DE ESTADO (Cont.) Un diagrama de estado representa el ciclo de vida de un objeto: Los eventos que le ocurren, sus transiciones y los estados que median entre esos eventos. Un diagrama de estado puede aplicarse a:

Clases de software. Tipos (conceptos). Casos de uso.

DIAGRAMAS DE ESTADO PARA LOS CASOS DE USO Se aplican de manera útil para descubrir la secuencia permitida de eventos externos del sistema que reconoce y maneja un sistema dentro del contexto de un caso de uso.

TIPOS Y CLASES COMUNES DEPENDIENTES DEL ESTADO Lista de clases o tipos comunes que suelen depender del estado y para los cuales posiblemente convenga elaborar un diagrama de estado:

Casos de uso (procesos). Visto como tipo, el caso de uso ComprarProductos reacciona de modo distinto ante el evento terminarVenta según que una venta esté realizándose o no.

Sistemas. Un tipo que representa la aplicación o sistema ínEtel g“sriosst.ema del punto-de- venta“.

Ventanas La acción de editar-pegar sólo es válida cuando hay algo en el “porta-papeles“para pegar.

TIPOS Y CLASES COMUNES DEPENDIENTES DEL ESTADO

Coordinadores de aplicaciones. “Applets“en Java. “Documents“en el esquema de aplicación Document-view de MFC C++ de Microsoft. “AplicationsModels“en el esquema de aplicación de SmallTalk de VisualWorks. “VisualParts“ en Smalltalk de VisualAge.

Controladores. Una clase que no administra aplicaciones ni ventanas y que se encarga de manejar los eventos del sistema, como se explicó en el patrón Controlador de GRASP. La clase TPDV, que maneja los eventos introducirProducto y terminar-Venta del sistema. TIPOS Y CLASES COMUNES DEPENDIENTES DEL ESTADO

Transacciones. La forma en que una transacción reacciona ante un evento a menudo depende de su estado actual a lo largo de todo su ciclo de vida. Si una Venta recibió un mensaje hacerLineadeProducto después del evento terminarVenta, debería presentar una condición de error o ser omitida.

Dispositivos. TPDV, televisor, lámpara, módem; reaccionan de modo distinto ante un evento particular, según su estado actual.

Mutadores. Tipos que cambian su tipo o su papel. Una persona que cambia papeles: de civil a militar.

DIAGRAMAS DE ESTADO PARA EVENTOS INTERNOS

Prefiera los diagramas de estado para describir eventos externos temporales, así como su reacción frente a ellos, en vez de servirse de ellos para diseñar el comportamiento de los objetos a partir de eventos internos.

ACCIONES Y PROTECCIONES DE LAS TRANSICIONES

ESTADOS ANIDADOS