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

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

3. 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);
}
}

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

5. 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;

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

7. 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”);

8. }
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();
}
}
}

9. 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.)

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

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

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