Programación orientada a objetos sergio augusto cardona torres

Programación Orientada a Objetos
Este libro está inspirado en el proyecto CUPI2, realizado por la Universidad de los
Andes, cuyo principal propósito es encontrar mejores formas de enseñar/aprender
a resolver problemas haciendo uso de un lenguaje de programación
Sonia Jaramillo Valbuena Adscrito al
Programa de Ingeniería de Sistemas y Computación Facultad de Ingeniería
Universidad del Quindío
Sergio Augusto Cardona Torres Adscrito al
Leonardo Alonso Hernández Rodríguez Adscrito al

Programación Orientada a Objetos
No está permitida la reproducción total o parcial de esta obra, ni su tratamiento o
transmisión por cualquier método sin autorización escrita deleditor.
Derechos reservados
ISBN: 978-958-44-7914-3 200 ejemplares
©Derechos reservados
Reproducido y editado por Ediciones Elizcom Primera edición, diciembre del 2010
200 ejemplares
www.elizcom.com
ventas@elizcom.com
Fax: 57 +6 +7450655
Móvil: 57 +3113349748
Armenia, Quindío
Colombia
PROGRAMACIÓN ORIENTADA A OBJETOS CONTENIDO
Pág.
ESTRUCTURAS CONTENEDORAS DE TAMAÑO FIJO
..................................................................................... 9
1
Objetivos.......................................................................................................................
9
2
Motivación.....................................................................................................................
9
3 Caso de estudio N.1 La Empresa (Código Fuente: unidadICaso01Empresa)
............................................ 9

3.1 Comprensión de los requisitos
............................................................................................................. 10
3 2 Comprensión del mundo del
problema................................................................................................. 11
3 3
Arreglos..........................................................................................................................
11
3.4 Recorrer los arreglos
........................................................................................................................... 13
3 5 Patrones para instrucciones
repetitivas................................................................................................ 16
3.6 El manejo de la memoria en Java
........................................................................................................ 18
3.7 Excepciones
.......................................................................................................................................
18
3.8 Diseño por contrato
............................................................................................................................. 20
4 Caso de estudio N.2 Cine ElizMark (Código Fuente: unidadICaso02Cine)
.............................................. 27
............................................................................................................. 28
problema................................................................................................. 28
4 3 Diseño y construcción de la solución del problema
.............................................................................. 30
5 Hoja de trabajo 1 La Biblioteca (Código Fuente:
unidadIHoja01Biblioteca).............................................. 36
............................................................................................................. 37

problema................................................................................................. 37
.............................................................................. 39
6 Hoja de trabajo N.2 Universidad (Código Fuente: unidadIHoja02Universidad)
........................................ 45
6.1 Requisitos funcionales
.................................................................................................................... 45
problema............................................................................................ 46
......................................................................... 48
ESTRUCTURAS CONTENEDORAS DE TAMAÑO
VARIABLE.......................................................................... 53
1 Objetivos
.......................................................................................................................................
53
2 Motivación
.......................................................................................................................................
53
3 Caso de estudio N.1 Conjuntos (Código Fuente:
unidadIICaso01Conjuntos)............................................... 53
.................................................................................................................... 54
problema............................................................................................ 55
......................................................................... 57
4 Caso de estudio N.2 Conjunto Cerrado (Código
Fuente:unidadIICaso02ConjuntoCerrado)..................... 62

.................................................................................................................... 63
problema............................................................................................ 64
......................................................................... 65
5 Caso de estudio N.1 El Avión (Código Fuente: unidadIIHoja01Avion)
......................................................... 67
.................................................................................................................... 68
problema............................................................................................ 68
......................................................................... 69
5.4 Enum como nuevo elementos de
modelado.................................................................................... 72
5 5 foreach en Java
.............................................................................................................................. 73
6 Caso de estudio N.1 El Banco (Código Fuente: unidadI Hoja02Banco)
................................................... 74
.................................................................................................................... 75
problema............................................................................................ 76
......................................................................... 76
ARRAY
B D MENSIONAL...........................................................................................................
81
1 Objetivos

.......................................................................................................................................
81
2 Motivación
.......................................................................................................................................
81
3 Caso de estudio N.1 El cine (Código Fuente: unidadIIICaso01Cine)
........................................................... 81
.................................................................................................................... 82
problema............................................................................................ 82
......................................................................... 84
3.4 Patrones para recorrido sobre matrices
.......................................................................................... 87
4 Caso de estudio N.2 El Bingo (Código Fuente: unidadIIICaso02Bingo)
....................................................... 88
3 5 Requisitos funcionales
.................................................................................................................... 89
3.6 Comprensión del mundo del
problema............................................................................................ 90
3.7 Diseño y construcción de la solución del problema
......................................................................... 92
4 Hoja de Trabajo N.1 El Triqui (Código Fuente:
unidadIIIHoja01Triqui)..................................................... 96
.................................................................................................................... 97
problema............................................................................................ 97

......................................................................... 98
5 Hoja de Trabajo N 2 Concéntrese (Código Fuente: unidadII Hoja02JuegoParejas)
............................... 102
.................................................................................................................. 103
problema.......................................................................................... 104
....................................................................... 104
PERSISTENCIA
.......................................................................................................................................
109
1 Objetivos
.......................................................................................................................................
109
2 Motivación
.......................................................................................................................................
109
3 Caso de estudio N.1 La Empresa (Código Fuente: unidadIVCaso01Empresa)
.......................................... 109
.................................................................................................................. 110
problema.......................................................................................... 110
....................................................................... 112
3.4 Archivos
.......................................................................................................................................
112
3 5 Métodos de ordenamiento y búsqueda

......................................................................................... 116
3 5 Pruebas de
software.....................................................................................................................
122
4 Caso de estudio N.2 La Libreta Telefónica (Código Fuente:
unidadIVCaso02LibretaTelefonica) ........... 129
.................................................................................................................. 130
problema.......................................................................................... 131
....................................................................... 131
4.4 Serializacion
.................................................................................................................................
135
5 Hoja de trabajo N.1 El Ahorcado (Código Fuente: unidadIVHoja01Ahorcado)
....................................... 136
.................................................................................................................. 137
problema.......................................................................................... 137
....................................................................... 138
6 Caso de estudio N.2 La Tienda Paisa (Código Fuente:
unidadIVHoja01TiendaPaisa)........................... 141
.................................................................................................................. 142
problema.......................................................................................... 143

....................................................................... 143
B BLIOGRAFIA.............................................................................................................
147
PREFACIO
El presente libro está inspirado en el proyecto CUPI2 realizado por la Universidad
de los Andes, cuyo principal propósito es encontrar mejores formas de
enseñar/aprender a resolver problemas haciendo uso de un lenguaje de
programación.
Para el entendimiento de este libro es necesario contar conconocimientos básicos
en:clases y objetos, expresiones, estructuras de decisión y ciclos.
El libro se estructura en 4 capítulos
1) Estructuras contenedoras de tamaño fijo. El lector podrá utilizar estructuras
repetitivas para resolver problemas que involucren el uso de estructuras
contenedoras estáticas y conocerá los diferentes patrones para recorrer este tipo
de estructuras. También se familiarizará con la metodología de Diseño por contrato
y el manejo de excepciones.
2) Estructuras contenedoras de tamaño variable. El lector estará en capacidad de
utilizar estructuras repetitivas para resolver problemas que involucren el uso de
estructuras contenedoras. Además, conocerá el método de ordenamiento Burbuja y
nuevos tipos de estructuras, tales como el foreach y enumeraciones.
3) Arreglos bidimensionales. El lector manejará el concepto de estructuras
contenedoras en dos dimensiones y podrá aplicar los diferentes patrones de
recorrido.
4) Serialización. El lector adquirirá reforzará su conocimiento respecto a
estructuras contenedoras yserá capaz de lograr que la información sea persistente,

para ello se incorporarán los temas de archivosProperties, serialización y
Generics. De igual forma, hará uso de excepciones personalizadas que le
permitirán garantizar que la información digitada es correcta.También, se
introducirá el concepto de pruebas con el JUnit. Finalmente se reforzarán los
conocimientos con respecto a métodos de ordenamiento y se incorporará el
concepto de búsqueda binaria.
El código fuente de cada uno de los ejemplos desarrollados en este libro se
encuentra en el CD anexo. Es de anotar, que todos los proyectos explicados
hacen uso de interfaz gráfica.
Para finalizar este prefacio es importante agradecer a la Universidad de los
Andespor su importante proyecto CUPI2, pues éste es fuente de inspiración para
muchas universidades y un importante avance para la solución del típico problema
de enseñar a programar.
ESTRUCTURAS CONTENEDORAS DE TAMAÑO FIJO
Objetivos
Al finalizar la unidad el estudiante estará en capacidad de:
Utilizar estructuras contenedoras de tamaño fijo para resolver problemas en los
cuales es necesario almacenar una secuencia de elementos del mismo tipo
Utilizar ciclos para poder manipular las estructuras contenedoras fijas
Utilizar la metodología de Diseño por contrato logrando con ello que a medida que
se programe se documente el código y se detecten errores.
Utilizar la clase Exception para capturar y manipular errores que pueden surgir en
tiempo de ejecución.
Motivación
En algunas ocasiones se requiere resolver problemas en los cuales es necesario
almacenar una secuencia de elementos, por ejemplo: un listado de estudiantes, de
productos o de empleados. Esta característica debe verse reflejada al momento de

construir el diagrama de clases. Además, al momento de plantear la soluciónese
grupo de elementos se debe materializar, es aquí en donde el aplica el concepto
de arreglos.
En este capítulo además de los arreglos se estudiarán otras temáticas, tales
como: ciclos, metodología de diseño por contrato y excepciones. Estás últimas
permitirán capturar y tratar los errores inesperados que surgen durante la ejecución
de un programa.
Caso de estudio N.1 La Empresa (Código Fuente: unidadICaso01Empresa)
Se desea crear una aplicación para manejar la información de una empresa, en la
cual hay 6 empleados. Cada empleado tiene un nombre, un código, una edad y un
salario. La aplicación debe permitir cambiar la información de cada empleado,
incrementar en un 10% el salario de todos los empleados, informar la cantidad de
empleados cuyo nombre inicia en la vocal especificada por el usuario, informar la
cantidad de empleados con edad superior a 30 e imprimir el salario promedio.

Descripción
Requisito funcional 4
Requisito funcional 5 Entrada
Salida
Nombre
Descripción Entrada
Salida
Nombre
Salida
Modificar la información del empleado
El usuario podrá modificar cualquiera de los 4 datos del empleado. 1)El número del
empleado al que se le va a modificar la información 2) Los nuevos datos: nombre,
código, edad o salario
La información del empleado ha sido modificada
incrementar en un 10% el salario
Se requiere incrementar en un 10% el salario de todos los empleados
Ninguna
Se ha incrementado el salario a todos los empleados
Informar la cantidad de empleados cuyo nombre inicia en la vocal especificada por
el usuario
El usuario selecciona una de las cinco vocales y la aplicación debe informar
cuantos empleados tienen nombre que inicie en dicha vocal
La vocal
La cantidad de empleados con nombre que inicia en esa vocal Informar la cantidad
de empleados con edad superior a 30 Se deben contar los empleados que tienen
edad superior a 30 Ninguna
La cantidad de empleados con edad superior a 30
Informar el salario promedio

Se requiere calcular el salario promedio de la empresa
Ninguna
El salario promedio
3.2 Comprensión del mundo del problema
El modelo conceptual se puede definir a través de dos clases: Empleado y
Empresa, tal como se muestra a continuación:

elementos que seconocer la cantidad de elementos que se van a almacenar.
En Java todos los arreglos son objetos. Los arreglos pueden ser
unidimensionales, bidimensionales o multidimensionales, pero esta unidad se
concentra en los unidimensionales.
Todo arreglo debe declararse y se le debe reservar memoria para poder ser
utilizado. Un arreglo se declara de la siguiente forma: <tipo>[] <nombre>;
También es válido: <tipo><nombre>[];
Un ejemplo concreto de cómo se declara un arreglo es:
int[] edades;
ó int edades[];
Es importante resaltar, que hasta ahora solo se ha declarado el arreglo, no ha sido
creado. Para crear un arreglo se le debe reservar memoria, a través del
operadornew:
edades = new int[10];
También es posible iniciar un arreglo al momento de su declaración, ejemplo: int
edades[]={4,56,34,13};
Luego de que se reserva memoria Java inicializa los arreglos dependiendo del tipo
de dato, ejemplo si el arreglo es de enteros, se inicializa por defecto con ceros,
pero si es de objetos se inicializa con null.
Cuando se declara un arreglo se debe usar el operador de indexación “ []” . Este
indica que se va a almacenar una lista de elementos del mismo tipo. Gracias a
este operador es posible acceder a cada uno de los elementos almacenados en la
estructura contenedora fija. Ello se logra escribiendo primero el nombre del array,
seguido de los corchetes que tendrán en su interior una variable de tipo entero,
denominada índice, que indicará la posición a la cual se desea acceder. Ejemplo,
si se tiene el siguiente arreglo:
Empleado misEmpleados[];
misEmpleados=new Empleado[MAXIMO_EMPLEADOS];

y se desea tener acceso a la posición 2, una instrucción correcta sería:
if(misEmpleados[2]!=null&&
misEmpleados[2].getCodigo().equals(codigo)) {return
true;}
Lo anterior significa que si hay un empleado en la posición 2 y el código del
empleado corresponde con el buscado se retorna true.
Algunas características importantes de los arreglos son las siguientes:
1. Tienen una variable denominada length que permite conocer el tamaño del
arreglo o array.
2. Para poder acceder a los elementos del arreglo se utilizan corchetes [] y un
índice que varía entre 0 y la longitud del arreglo-1, es decir, arreglo length-1.
3. Se pueden crear arrays de objetos pero hay que tener precaución pues luego de
reservarle memoria al arreglo será necesario crear cada uno de los objetos que van
a almacenar.
Retomando el desarrollo del caso de estudio será necesario entonces declarar un
arreglo de Empleados, tal como se muestra a continuación:
publicclass Empresa {
//----------------------------------------------------
------------// Atributos
//----------------------------------------------------
------------
private Empleado misEmpleados[];
//----------------------------------------------------
------------// Constantes
//----------------------------------------------------
------------privatefinalstaticintMAXIMO_EMPLEADOS=6;
//----------------------------------------------------

------------// Constructor
//----------------------------------------------------
------------
/**
* Método constructor de la clase
* post: Se crea una empresa en la que pueden haber
máximo 6 empleados */
public Empresa()
{
misEmpleados=new Empleado[MAXIMO_EMPLEADOS];}
}
3.4 Recorrer los arreglos
Para poder recorrer un arreglo es necesario hacer uso de una estructura repetitiva.
Java posee tres estructuras repetitivas: el for, el while y el do-while.
Toda estructura repetitiva posee tres partes básicas, a saber:
Expresión condicional o Decisión
Cuerpo del ciclo: en esta parte se ponen las instrucciones que se desea ejecutar
repetitivamente un cierto número de veces.
Salida del ciclo
En general, los ciclos se controlan a través de un contador, una variable que
aumenta o disminuye su valor en una cantidad fija cada vez que se efectúa la
repetición.
También, es común encontrar dentro de los ciclos variables acumuladoras, las
cuales permiten almacenar una cantidad variable cada vez que se efectúa una
repetición. Por ejemplo, cuando se requiere realizar una sumatoria o sacar un
promedio.
La primera estructura que se analizará será el while. Esta estructura tiene la
siguiente forma:

while ( condición ) {
acción 1
........
acción n
}
En este tipo de estructura las acciones se repiten “ mientras” que se cumple una
determinada condición, la cual se especifica al inicio dentro de paréntesis.
Cuando se efectúa la última acción se debe volver a evaluar la condición que del
"while" para verificar si nuevamente se ejecutan las instrucciones o si por el
contrario se finaliza la ejecución del while.
El do-while, es una estructura que permite que las acciones se ejecuten almenos
una vez antes de que se verifique la condición de repetición.
do
{
acción 1
........
acción n
} while( condición );
En el while en principio se ejecutan todas las acciones y luego se evalúa la
condición, si ésta da como resultado true nuevamente se repiten las acciones, de
lo contrario se finaliza el ciclo.
La última estructura repetitiva, y la más usada para trabajar con arreglos, es el
ciclo for,que funciona de la siguiente forma:
for ( inicialización; condicion; iteración) {
acción 1
........

acción n
}
En el for lo primero que se ejecuta es la inicialización, la cual normalmente es una
expresión de asignación. La inicialización solo se efectúa una vez. A
continuación, se evalúa la condición y si da verdadero se ejecuta el cuerpo del
ciclo. En caso de que de false, el ciclo finaliza.
Luego se efectúa la iteración, que consiste en aumentar o disminuir la variable de
control del ciclo.
Ahora bien, luego de esta conceptualización se continuará con el desarrollo de
este caso de estudio Para responder a los requisitos funcionales es necesario
construir varios métodos, algunos de los cuales se explicarán a continuación:
El métodoincrementarEn10() se encarga de aumentar el salario de todos los
empleados en un 10% . Este método no requiere de parámetros. El método
funciona de la siguiente forma: Se crea un ciclo for que inicia en 0 y va hasta la
cantidad de empleados. Es importante preguntar en cada posición si se ha
registrado un empleado, es decir, si no es null. En caso de que sea así, se llama al
método setSalario para ese empleado y se le fija el nuevo salario.
publicvoid incrementarEn10()
{
for(int i=0; i<MAXIMO_EMPLEADOS;i++) {
if(misEmpleados[i]!=null)
{
misEmpleados[i].setSalario(misEmpleados[i].getSalario(
}
}
}

El método contarVocal es el encargado de informar la cantidad de empleados cuyo
nombre inicia en la vocal especificada por el usuario. Este método tiene un
parámetro, la vocal. Para poder conocer la cantidad de empleados cuyo nombre
inicia en dicha vocal se debe plantear una estructura repetitiva que permita recorrer
todo el arreglo y verificar en caso de que exista un empleado si su nombre inicia
en esa vocal.
publicint contarVocal(char vocal) {
int contador=0; String nombre="";
for (int i=0; i<MAXIMO_EMPLEADOS; i++)
{
{ nombre=misEmpleados[i].getNombre().toUpperCase();
if(nombre.charAt(0)==vocal)
{
contador++;
}
}
}
return contador;
}
Observe que a través de la instrucción:
nombre=misEmpleados[i].getNombre().toUpperCase();
Se captura el nombre del empleado y se pasa a mayúscula. Es importante que
tenga claro, que los códigos de las letras mayúsculas son diferentes a los de las
minúsculas.
En el método anterior se hizo uso del método charAt. Este permite obtener un
caracter de un String indicando la posición deseada, ejemplo si se desea obtener

la posición cero la instrucción válida es nombre.charAt(0), si se requiere la
posición 1 la instrucción es nombre.charAt(1), si se necesita la posición i se
escribe nombre.charAt(i).
El método contarEmpleadosMayores30() permite obtener la cantidad de empleados
con edad superior a 30. En éste se recorre todo el arreglo y a cada empleado
existente se le pregunta la edad. En caso de que la edad sea superior a 30 se
debe contabilizar.
publicint contarEmpleadosMayores30() {
int contador=0;
for (int i=0; i<MAXIMO_EMPLEADOS; i++) {
if(misEmpleados[i]!=null&&misEmpleados[i].getEdad()>30
{
contador++; }
}
return contador;
}
3.5 Patrones para instrucciones repetitivas
Un patrón es una solución genérica para un problema. Son tres los patrones que se
trabajarán referentes a estructuras repetitivas, ellos son1
:
a) Patrón de recorrido Total
Mediante este patrón se tiene acceso a cada una de las posiciones del arreglo, por
ello es necesario que el índice inicie en cero y se incremente de uno en uno hasta
llegar a la cantidad de elementos del arreglo-1. También, el índice podría iniciar en
la cantidad de elementos del arreglo-1 e ir decrementando de uno en uno hasta
llegar a cero.
Un ejemplo de este tipo de patrón es el siguiente:

publicdouble calcularPromedio() {
double acumulador=0;
int contador=0;
for (int i=0; i<MAXIMO_EMPLEADOS;i++) {
{
acumulador+=misEmpleados[i].getSalario(); contador++;
}
}
b) Patrón de Recorrido Parcial
Se recorre el arreglo y por cada elemento se verifica si ya se cumplió la condición
de finalización del ciclo, es decir, si el problema ya fue resuelto. Por ejemplo, se
necesita obtener el primer empleado con edad superior a 35 años, o buscar el
empleado cuya cédula es 415. Luego de encontrar el dato requerido no tiene
sentido seguirse moviendo en el arreglo.
1Estos patrones están descritos en el libro Fundamentos de
Programación. Aprendizaje activo Basado en Casos de Jorge
Villalobos y Rubby Casallas
publicint buscarEmpleado(String codigo)
{
for(int i=0; i<MAXIMO_EMPLEADOS;i++)
{
if(misEmpleados[i]!=null&&misEmpleados[i].getCodigo().e
{ return i;}
}
return -1;
}

Este mismo método se pudo haber planteadotambién de la siguiente forma:
publicint buscarEmpleado(String codigo) {
boolean centinela=false;
int posicion=-1;
for (int i=0;
i<MAXIMO_EMPLEADOS&&centinela==false;i++)
{
if(misEmpleados[i]!=null&&
misEmpleados[i].getCodigo().equals(codigo)) {
posicion=i; centinela=true;
}
}
return posicion;
}
En esta última forma se declara un booleano que controla la finalización del ciclo.
c) Patrón de doble recorrido
En este tipo de patrón por cada elemento del array se realiza un recorrido
completo.
public Empleado determinarMayorFrecuencia()
{
int edad, contador = 0, mayorFrecuencia = 0,
guardaContador = 0;
for ( int i = 0 ; i < misEmpleados.length ; i++ ) {
//Aquí se obtiene cada uno de los elementos del array
edad = misEmpleados [i].getEdad();
contador = 0;

for ( int j = 0 ; j < misEmpleados.length; j++ ) {
if( i != j )
{
if( edad == misEmpleados[j].getEdad() )
{
contador++; }
}
}
//Aquí se compara el contador de ocurrencias del
elemento actual con el contador //general
if( contador > guardaContador )
{ guardaContador = contador;mayorFrecuencia = i; }
}//Cierra el for
return misEmpleados[mayorFrecuencia];
}
3.6 El manejo de la memoria en Java
La memoria está dividida en tres zonas, a saber: la Zona de Datos, el Stack o
Memoria de pila y el Heap, o Memoria de montículo. En la primera de ellas, se
almacenan las instrucciones del programa, las constantes, los métodosy las
clases. En el Stack se guardan las referencias a objetos (es decir, instancias
creadas con new) y las variables de tipo de dato primitivo, másconcretamente,
parámetros y variables locales. En el Heap, la zona de memoria dinámica, se
almacenan los objetos creados. La forma como el heap y el stack interaccionan
puede verse en el siguiente gráfico:
Empleado misEmpleados[];
finalstaticintMAXIMO_EMPLEADOS=3;
misEmpleados=new Empleado[MAXIMO_EMPLEADOS];
misEmpleados[0]= new Empleado(2,3000);

edad, salario);
}
catch (Exception e1) {
JOptionPane.showMessageDialog(null, e1.getMessage());
}
}
Lo anterior puede interpretarse como:
Si se produce un error al llamarse el método agregarEmpleado se genera una
excepción que es capturada, logrando con ello que la ejecución del programa
salte al catch. Dentro del catch se solicita el mensaje del error que ha ocurrido a
través de la variable e1, el cual se imprime haciendo uso del JOptionPane.
Para forzar a que se ejecute algo después de generada una excepción se escribe
finally. El formato general es:
try
{…
}
catch (Exception e) {…
}
finally
{…
}
Si el objetivo es generar una excepción dentro de un método se utiliza throw.
Dichas excepciones se definen creando una subclase de Exception. Cuando
dentro de un método se lanza una excepción derivada de Exception es necesario
añadir la palabra reservada throws en la cabecera del método seguida de la lista
de excepciones que se pueden producir, ejemplo:

publicboolean agregarEmpleado(int posicion, String
codigo, String nombre, int horasTrabajadas,double
valorHora)throws EmpleadoRepetidoException {
if(buscarEmpleado(codigo)==-1)
{
Empleado miE=new
Empleado(codigo,nombre,horasTrabajadas,valorHora);
misEmpleados[posicion]=miE;
verificarInvariante( );
returntrue;
}
else
thrownew EmpleadoRepetidoException("El empleado ya
existe");
}
En el caso anterior se creó un nuevo tipo de excepción
denominadoEmpleadoRepetidoException. Ello se logró definiendo una subclase
del tipo Exception.
publicclass EmpleadoRepetidoException extends
Exception{ public EmpleadoRepetidoException(String
mensaje) {
super (mensaje); }
}
El proceso que se sigue para crear este tipo de clases consiste en crear una
nueva clase que extienda de Exception. En su interior se pone solamente un
método constructor, que recibe como único parámetro el mensaje de error que se
desea mostrar. En este caso, la instrucción super hace referencia al constructor de
la clase base, es decir, al constructor de Exception.

Es muy común que en los programas se definan excepciones propias que hereden
de la clase Exception, pues gracias a ello es posible representar situaciones
particulares para cada problema.
3.8 Diseño por contrato
El Diseño por contrato es una metodología que se popularizó por el lenguaje de
programación Eiffel y sefundamenta en la idea de que cada elemento de diseño es
un participante dentro de una relación análoga a un contrato de negocios. Es decir,
las relaciones entre las clases y sus clientes pueden interpretarse como un
acuerdo o contrato, en el que se expresan los deberes y derechos de cada uno de
los participantes. Esto permite que si ocurre algún problemacon remitirse al
contrato sea posibledeterminar quién era el responsable de ejecutar la tarea que
falló.
Para complementar lo anterior, es importante recordar que para asignar
responsabilidades es posible apoyarse en la técnica del experto o en la técnica
de descomposición por requerimientos. La primera de ellas se basa en la idea de
que el dueño de la información es el responsable de ella y la segunda, en que para
satisfacer un requisito funcional una forma apropiada es descomponerlo en
subproblemas para poder solucionar al requisito completo.
El Diseño por Contrato hace posible diseñar componentespartiendo del hecho que
se efectuaránunas determinadas condiciones de entrada y que se garantizará el
cumplimiento de ciertas condiciones de salida. De igual forma,considera que debe
haber propiedades que no varíen sin importar el procesamiento que se realice
dentro de un componente.
Partiendo de lo anterior, se puede afirmar que un contrato incluye tres tipos de
restricciones: invariante, precondición y postcondición.
- Una invariante es una condición booleana cuyo resultado siempre debe ser true
para todas las instancias de la clase. La invariante permite verificar la

consistencia de los atributos de la clase.
- Una precondición es un predicado que debe haberse efectuado antes de que se
realice una determinada operación.
- Una postcondición es un predicado que, luego de haber ejecutado una determinar
operación, debe ser verdadero.
El Diseño por Contrato ofrece entre otras ventajas las siguientes:
Un efectivo sistema para detectar y disminuir errores en el código, debido a la
clara definición de las especificaciones.
Una forma sencilla de documentar el codigo fuente a medida que se programa.
a. El contrato de un método
El contrato de un método incluye la especificación de las precondiciones y las
postcondiciones. Por ejemplo, si se considera el siguiente método:
valorHora)
Se puede decir que las condiciones previas, o precondiciones, que deben
cumplirse para que este método se ejecute son:
El array de empleados ya se declaró y se le reservó memoria El código no es
null, ni vacío
El nombre no es null, ni vacío
La cantidad de horas trabajadas es un número positivo El valor de la hora es un
número positivo
No se sabe si hay un empleado con este código
La precondición expresa las restricciones necesarias para que la operación
funcione de forma adecuada.
El resultado de la ejecución del método debe ser: Se agregó el empleado
Se produjo un error y no se pudo agregar

La precondición son las condiciones impuestas para que se dé el desarrollo del
método, mientras que la postcondición son los compromisos aceptados.
b.Documentación de los contratos
Para documentar los contratos es necesario apoyarse en Javadoc. Javadoc es
una herramienta que permite generar un conjunto de páginas web a partir de los
archivos de código que contengan los delimitadores /**… */.Javadoc permiteque la
arquitectura de la solución sea mucho más comprensible.
Para lograr una adecuada documentación del contrato se debenagregar
comentarios a cada uno de los métodos que componen el programa.
Un comentario permite agregar información suficiente para que otras personas
puedan entender lo que se ha hecho y el porqué de lo que se ha hecho.
Documentar no sólo es un acto de buena programación, es además una necesidad
para poder entender el programa a medida que crece y poder identificar posibles
fuentes de error.
Una correcta documentación facilita que un software pueda ser modificado a
futuro, ya sea por su creador o por cualquier otro programador que lo reemplace.
Cuando se documenta se debe explicar lo que no es evidente. Es decir, se debe
explicar por qué se hacen las cosas, en lugar de repetir lo que se hace. Cuando se
empiece la construcción del software es importante explicar:
Función de cada clase o paquete
La labor de cada método y cuál es su uso esperado
Por qué se declaró una variable
Cómo funciona el algoritmo que se está utilizando y que limitaciones tiene
Posibles mejoras que podrían realizarse
Es obligatorio poner documentación javadoc en los siguientes casos:
Al inicio de cada clase Acada atributo
Al inicio de cada método

La escritura de un comentario Javadoc exigen seguir una sintaxis. Deben iniciar
por "/**" y terminar por "*/":
/**
* Descripción clara, breve y contundente de lo que
hace. *
* @etiqueta texto para la etiqueta
*/
Una descripción de las posibles etiquetas a utilizar para documentar una clase se
muestra a continuación:
@author Nombre del autor
@version Información sobre la versión y fecha @see
Referencia con otras clases y métodos
En la documentación de los constructores y métodos se deben utilizar al menos
las etiquetas siguientes:
@param
@return
@exception ó @throws
La siguiente tabla ilustra las posibles etiquetas que pueden utilizarse para
documentar un método:
@param Nombre del parámetro
@return Si el métodono es void
@exception Nombre de la excepción ó
@throws
Descripción, uso y valores válidos
Descripción de lo que se debe devolver

Excepciones que pueden surgir durante la ejecución
Acontinuación se muestra un ejemplo de uso de algunas etiquetas Javadoc para
documentar el código:
- Al inicio de la clase
/**
*
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id$
* Universidad del Quindío(Armenia- Colombia)
* Programa de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License
* Fundamentos de Algoritmia
* Ejercicio: unidadICaso01Empresa
* @author Sonia Jaramillo Valbuena
* @author Sergio Augusto Cardona
* @author Leonardo Hernández
*
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package
uniquindio.fundamentos.unidadICaso01Empresa.mundo; /**
* Clase que representa una Empresa
*/
publicclass Empresa {
}
- Por cada método
/**

* Permite agregar un empleado.
* @param posicion La posicion del empleado que se
desea agregar. posicion>=0&& *
posicion<MAXIMO_EMPLEADOS
* @param codigo El código del empleado. codigo!=null
&& !codigo.equals(" ") * @param nombre El nombre del
empleado. nombre!=null && !nombre.equals(" ") * @param
horasTrabajadas Es la cantidad de horas que trabaja el
empleado. * horasTrabajadas>0
* @param valorHora Es el valor que se le paga al
empleado por cada hora * trabajada. valorHora>0
* @throws Exception Si existe un empleado con el mismo
codigo se lanza una * excepción indicando que no se
pudo agregar
*/
valorHora)throws EmpleadoRepetidoException {
if(buscarEmpleado(codigo)==-1)
{
Empleado miE=new Empleado(codigo,
nombre,horasTrabajadas,valorHora);
misEmpleados[posicion]=miE;
returntrue;
}
else
thrownew EmpleadoRepetidoException("El empleado ya
existe");
}
Luego de finalizar la documentación se puede generar el archivo html con la
documentación. Los pasos para ello son:

Es de anotar, que los modificadores utilizados y el tipo devuelto no forman parte de
la signatura del método.También, es importante recalcarque no puede haber dos
métodos que con la misma signatura en una misma clase.
Para el diseño de la signatura de un método se debe tener en cuenta las entradas
y salidas del requisito funcional que el método pretende resolver, además, del tipo
de dato de cada uno de los parámetros requeridos. Por ejemplo, si se tiene el
método:
valorHora)throws EmpleadoRepetidoException
Para poder cumplir con la responsabilidad de agregar un empleado el método
agregarEmpleado de la clase Empresa debe recibir la posición donde desea
agregar el empleado y los datos referentes a éste.
d. La invariante de la clase
El Diseño por Contrato requiere también la incorporación del concepto de
invariante. Una invariante es una condición booleana cuyo resultado siempre debe
ser true para todas las instancias de la clase. La invariante permite verificar la
consistencia de los atributos de la clase La invariante debe usarse al final del
constructor y de los métodos que modifican el estado del objeto.
La invariante hace uso de la instrucción assert. Un assert es una condición que se
debe dar en todo momento en un programa para que no se produzcan errores Hay
dos formas de escribir aseveraciones en Java:
assert (Expresión con resultado booleano) :
(Descripción del error) ; ó
assert (Expresión con resultado booleano) ;

Observe que en ambas declaraciones se inicia con la palabra assert.
Por cada clase debe construirse un método para verificar la invariante.
Acontinuación se incluyen los métodos verificarInvariante para la cada una de las
clases del caso de estudio de la Empresa.
verificarInvariante para la clase Empleado
// ---------------------------------------------------
-------------// Invariante
// ---------------------------------------------------
-------------/**
* Verifica que el invariante de la clase se cumpla. Si
algo falla, lanza un error * 
* inv: 
* misEmpleados !=null 
* los códigos de los empleados son únicos 
*/
publicvoid verificarInvariante( )
{
assert (misEmpleados!=null) : "El arreglo no puede ser
null"; assert (verificarConsistencia()==true):"Hay
códigos repetidos"; }
verificarInvariante para la clase Empresa
// ---------------------------------------------------
-------------// Invariante
// ---------------------------------------------------
-------------
/**
* Verifica que el invariante de la clase se cumpla. Si
algo falla, lanza un * error 
* inv:

* misEmpleados !=null 
* los códigos de los empleados son únicos 
*/
publicvoid verificarInvariante( )
{
assert (misEmpleados!=null) : "El arreglo no puede ser
null"; assert (verificarConsistencia()==true):"Hay
cï¿½digos repetidos"; }
publicboolean verificarConsistencia()
{boolean centinela=true;
int contador=0;
for(int i=0; i<MAXIMO_EMPLEADOS; i++)
{ contador=0;
for(int j=0; j<MAXIMO_EMPLEADOS; j++)
{
if(misEmpleados[i]!=null&&
misEmpleados[j]!=null&&misEmpleados[i].getCodigo().equa
go()))
{contador++;}
}
if(contador!=1)
{
returnfalse; }
}
return centinela;
}
Los assert en Eclipse no están habilitados por defecto. Para habilitarlos es
necesario dar clic en: Windows -> Preferences -> Java -> Installed JREs.
Luego hay que seleccionar el JDK y dar click el boton Edit y en el campo "Default

VM Arguments" escribir “ -ea” .

permitir eliminar una reservación indicando la cédula del cliente que la realizó.

1)cedula, 2)edad, 3)tipo, 4) Fecha de la solicitud (día, mes, año), 5)Hora de llegada
(discriminada por hora y minuto)
Se asigna una silla al cliente, siempre y cuando exista disponibilidad de acuerdo
a las preferencias del cliente y se le informa el valor a pagar
Liberar una silla
Se requiere cancelar una reservación ingresando para ello la cédula del cliente
que la realizó
cedula
Si efectivamente el cliente tenía reservada una silla, ésta reservación se cancela.
El modelo conceptual se puede definir a través de 6 clases:Cine, Puesto,
Reservación, Fecha y Persona. El diagrama de clases de este caso de estudio se

privateint dia, mes, anio;
privateint hora, minuto, segundo;
}
Adicionalmente, se requiere de los siguientes métodos:
- Un método constructor que permite crear una fecha con los datos del dia de hoy.
public Fecha()
{
// Usamos un calendario Gregoriano inicializado en el
día de hoy
GregorianCalendar gc = new GregorianCalendar( );
// Se obtienen los valores de dia, mes y año del
calendario dia = gc.get( Calendar.DAY_OF_MONTH );
mes = gc.get( Calendar.MONTH ) + 1;
anio = gc.get( Calendar.YEAR );
hora=gc.get( Calendar.HOUR );
minuto=gc.get( Calendar.MINUTE );
}
- Un método constructor par crear una fecha con el día, mes y año que el usuario
ingresa, además de la hora y de los minutos.
public Fecha(int dia, int mes, int anio, int hora, int
minuto) { this.dia = dia;
this.mes = mes;
this.anio = anio;
this.hora = hora;
this.minuto = minuto;
verificarInvariante();

}
El método calcularDiferenciaEnMinutos es el encargado de calcular la diferencia
en minutos entre dos fechas. Recibe como parámetro una fecha.
public Fecha calcularDiferenciaEnMinutos(Fecha
miFechaMayor) {
GregorianCalendar
menor=devolverGregorianCalendar(this);
GregorianCalendar
mayor=devolverGregorianCalendar(miFechaMayor); long
diferencia = mayor.getTime().getTime()-
menor.getTime().getTime(); double minutos = diferencia
/ (1000 * 60);
int horas = (int) (minutos / 60);
int minuto = (int) (minutos%60);
returnnew Fecha(0,0,0,horas,minuto);
}
El método devolverGregorianCalendar recibe un objeto de tipo Fecha y lo
convierte a Calendario Gregoriano
public GregorianCalendar
devolverGregorianCalendar(Fecha miFecha)
{
GregorianCalendar gcMenor = new GregorianCalendar( );
gcMenor.set(miFecha.getAnio(), miFecha.getMes()-1,
miFecha.getDia(), miFecha.getHora(),
miFecha.getMinuto());
return gcMenor;
}
Acontinuación se sobreescribe el método equals. Este método tiene como

objetivo comparar dos objetos de tipo Fecha, si son iguales devuelve true, de lo
contrario false.
publicboolean equals(Object o)
{
Fecha miFecha=(Fecha)(o);
if(dia==miFecha.getDia()&&anio==miFecha.getAnio()&&mes=
{ returntrue;}
else
{returnfalse;} }
Adicionalmente, se requiere construir la clase Persona
ACTIVIDAD
Complete la declaración de la clase Persona. Debe incluir los atributos, el
constructor y los métodos get y set.
publicclass Persona {
//----------------------------------------------------
--------//Atributos
//----------------------------------------------------
--------
//----------------------------------------------------
--------//Constructor
//----------------------------------------------------
--------public Persona(String cedula, int edad) {
}
//----------------------------------------------------
--------//Métodos
//----------------------------------------------------
--------

public String getCedula() { return cedula;
}
publicvoidsetCedula(String cedula) {
}
publicint getEdad() {
} publicvoid setEdad(int edad) {
} }
Por otro lado, en la clase Puestose deben declarar los siguientes atributos:
//----------------------------------------------------
------------// Atributos
//----------------------------------------------------
------------/**
* Es el número del puesto
*/
privateint numero;
/**
* Es el tipo del puesto, puede tomar los valores de
GENERAL O PREFERENCIAL
*/
privateint tipo;
/**
* Es el estado del puesto. El estado del puesto puede
ser ESTADO_LIBRE o
* ESTADO_OCUPADO
*/
privateint estado;
/**
* Es el arreglo de reservaciones */

private Reservacion misReservaciones[]; /**
* Es el contador de reservaciones */
privateint contadorReservaciones=0;
//----------------------------------------------------
------------//Constantes
//----------------------------------------------------
------------/**
* Representa al tipo general
*/
publicstaticfinalintGENERAL=1;
/**
* Representa al tipo preferencial
*/
publicstaticfinalintPREFERENCIAL=0;
/**
* Representa al estado libre
*/
publicstaticfinalintESTADO_LIBRE=0;
/**
* Representa al estado ocupado
*/
publicstaticfinalintESTADO_OCUPADO=1;
Se declara una estructura contenedora de 200 posiciones para poder manejar todo
lo referente a las reservaciones que se hagan sobre un puesto específico.
Se declaran 4 constantes, las dos primeras permiten representar los posibles tipos
de puestos (GENERAL y PREFERENCIAL) y las dos últimas permiten representar
los posibles valores del atributo estado (ESTADO_LIBRE y ESTADO_OCUPADO)
Algunos de los métodos más relevantes de la clase Puesto son:

- El constructor de la clase Puesto permite reservarle memoria al array de
Reservaciones.
public Puesto()
{
misReservaciones=new Reservacion[200]; }
- El método agregarReservacion tiene varios parámetros: String cedula, int
edad,int dia, int mes, int anio, int hora, int minuto yint tipo. Este método es el
encargado de crear una nueva reservación, siempre y cuando no se exceda el
máximo de reservaciones por puesto, es decir, 200. Cada vez que se genera una
reservación el estado del puesto se pone en ocupado.
public boolean agregarReservacion(String cedula,int
edad,int dia, int mes, int anio, int hora, int minuto,
int tipo)
{
Reservacion nueva=new Reservacion(new Persona(cedula,
edad),new Fecha(dia,mes,anio,hora,minuto),tipo);
if(contadorReservaciones<200)
{
misReservaciones[contadorReservaciones]=nueva;
contadorReservaciones++;
estado=ESTADO_OCUPADO;
return true;
}
return false;
}
Por último, se tiene la clase Cine, en la cual es necesario declarar un arreglo de
Puestos. Algunos de los métodos de esta clase son:

- El método constructor de la clase Cine. Aquí se le reserva memoria al arreglo de
puestos y también a cada puesto.
public Cine ()
{
//Se le reserva memoria al arreglo misPuestos=new
Puesto[MAXIMO];
//Se le reserva memoria a cada uno de los puestos que
hay en el arreglo for(int i=0; i<MAXIMO; i++)
{
misPuestos[i]= new Puesto();
misPuestos[i].setNumero(i+i);
misPuestos[i].setEstado(Puesto.ESTADO_LIBRE);
if (i>14)
misPuestos[i].setTipo(Puesto.GENERAL); else
misPuestos[i].setTipo(Puesto. PREFERENCIAL); }
}
- El método ubicarPersona tiene varios parámetros: String cedula, int edad, int tipo,
int dia, int mes, int anio, int hora yint minuto. Este método recorre el arreglo de
puesto, para ello se apoya en la preferencia que el cliente desea. Cuando
encuentra un puesto libre acorde a la preferencia solicitada le agrega una
reservación.
publicint ubicarPersona(String cedula, int edad, int
tipo, int dia, int mes, int anio, int hora, int
minuto)
{
int inicio=0, finaliza=14;

//Se verifica que la persona no esté ya sentada en el
cine if(buscarPersona(cedula, new Fecha(dia, mes,
anio,hora, minuto))==false) {
if(tipo==Puesto.GENERAL)
{
inicio=14; finaliza=56;
}
for(int i=inicio; i< finaliza;i++)
{
if(misPuestos[i].getEstado()==Puesto.ESTADO_LIBRE)
{
misPuestos[i].agregarReservacion(cedula, edad, dia,
mes, anio, hora, minuto,tipo);
return i;
}
}
}
return -1;
}
El método buscarPersona recibe la cédula de la persona y la fecha en la cual se le
realizó la reservación, en caso de que exista la reservación devuelve true.
publicboolean buscarPersona(String cedula, Fecha miF)
{
Fecha actual=new Fecha();
for (int i=0; i<MAXIMO; i++)
{
if(misPuestos[i].getContadorReservaciones()>=1&&
misPuestos[i].getMisReservaciones()

[misPuestos[i].getContadorReservaciones()1].getMiPerson
misPuestos[i].getEstado()==Puesto.ESTADO_OCUPADO&&
misPuestos[i].getMisReservaciones()
[misPuestos[i].getContadorReservaciones()1].getMiFechaE
{
returntrue;
}
}
returnfalse;
}
El método liberarEspacio recorre el arreglo de puestos y por cada uno de ellos
verifica si está ocupado. En tal caso compara la cedula de la persona que está
ocupando el puesto con la del cliente buscado, si son iguales pone el estado de la
silla en libre. Finalmente devuelve la posición donde estaba ubicada la persona y
el valor que debe pagar.
public ResultadoLiberacion liberarEspacio(String
cedula)
{
for(int i=0; i<MAXIMO; i++)
{
if(misPuestos[i].getContadorReservaciones()>=1&&misPue
()[misPuestos[i].getContadorReservaciones()
1].getMiPersona().getCedula().equals(cedula)&&
misPuestos[i].getEstado()==Puesto.ESTADO_OCUPADO)
{
misPuestos[i].setEstado(Puesto.ESTADO_LIBRE);
returnnew
ResultadoLiberacion(misPuestos[i].getMisReservaciones(
[misPuestos[i].getContador
Reservaciones()-1].calcularValorAPagar(), i);
}

}
returnnull;
}
}
Hoja de trabajo 1 La Biblioteca (Código Fuente: unidadIHoja01Biblioteca)
Un cliente requiere una aplicación para manejar la información de una Biblioteca.
La Biblioteca tiene un listado de autores, uno de libros, uno de clientes y otro de
préstamos. Cada una de estas listas tiene una cantidad máxima de 100.
La aplicación debe permitir:
Agregar un nuevo cliente, para lo cual se solicita su nombre y código
Agregar un nuevo autor, para lo cual se ingresa el código y nombre del autor
Agregar un nuevo libro ingresando código, nombre, cantidad de existencias,
género y listado de autores, los cuales deben previamente existir en el sistema.
Realizar un nuevo préstamo.
Informar cuál ha sido el libro más prestado
Informar que libros ha escrito un determinado autor
Listar los libros prestados por un determinado usuario
Listar los autores de un libro

Requisito funcional 4 Salida
Nombre
Descripción
Entrada
Nombre
Salida
Nombre
Descripción
Entrada
Nombre
Nombre
Salida
Agregar un nuevo cliente
Se debe agregar un nuevo cliente proporcionando para ello su información básica.
No se podrán agregar clientes que existan ya en el sistema.
1)nombre y 2)código
Un nuevo cliente ha sido agregado.
Agregar un nuevo autor
Se debe agregar un nuevo autor proporcionando para ello su información básica.
No se podrán agregar autores que existan ya en el sistema.

1)nombre y 2)código
Un nuevo autor ha sido agregado.
Agregar un nuevo libro
Se debe agregar un nuevo libro. No se podrán agregar libros que existan ya en el
sistema.
1) codigo,2)nombre, 3)cantidad de existencias, 4)género y 5)listado de autores
Un nuevo libro ha sido agregado
Realizar un nuevo préstamo
Se debe permitir agregar un nuevo préstamo. Es importante estar verificando que si
haya libros disponibles para prestar y que ha ese cliente no se le hay prestado ese
libro ya.
1) La posición en la cual está ubicado el libro dentro del arreglo de libros, 2) La
posición donde está ubicado el cliente que desea hacer el préstamo dentro del
arreglo de clientes
Un nuevo préstamo ha sido creado
Informar cuál ha sido el libro más prestado
Se debe devolver el libro que ha sido más prestado
Ninguna
El libro más prestado
Informar que libros ha escrito un determinado autor
Se selecciona el autor de un listado y se envía la posición donde estaba ubicado
para poder buscar los libros que éste ha escrito La posición donde está ubicado el
autor dentro del arreglo de autores.
El listado de libros
Listar los libros prestados por un determinado usuario
Se deben listar los libros prestados por un determinado usuario La posición donde
está ubicado el usuario dentro del arreglo de usuarios
El listado de libros prestados
Listar los autores de un libro
Se debe permitir listar los autores de un libro

1)posición donde está ubicado el libro dentro del arreglo de libros El listado de
autores del libro
Se pueden identificar diferentes entidades: Biblioteca, Cliente, Autor, Libro y
Préstamo:

}
public String toString()
{
return "cedula "+cedula+ " nombre "+nombre;
}}
El método toString devuelve la representación en String del objeto, en el caso del
Autor se devuelve la cédula y el nombre.
publicclass Cliente { private String cedula, nombre;
public Cliente (String cedula, String nombre) {
this.cedula = cedula;
this.nombre = nombre;
}
{
return "cedula "+cedula+ " nombre "+nombre;
}}
Por otro lado, en la clase Libro se requiere declarar los siguientes atributos:
publicclass Libro {
//----------------------------------------------------
------------// Atributos
//----------------------------------------------------
------------/**
* Ese el código isbn del libro
*/
private String codigo;
/**

* Es el nombre del libro
*/
private String nombre;
/**
* La cantidadDeExistencias representan la cantidad de
copias que hay por libro. */
privateint cantidadDeExistencias;
/**
* El género es un entero 0--> Programación, 1-->Bases
de datos, * 2-->Compiladores, 3-->Arquitectura
*/
privateint genero;
/*
* El array que contiene el listado de autores */
private Autor misAutores[];
/*
* Lleva la cuenta de los autores agregados */
privateint contadorAutores;
//----------------------------------------------------
//----------------------------------------------------
------------
/**
* Es la cantidad máxima de autores
*/
publicstaticfinalintMAXIMO_AUTORES=5;

El constructor de la clase Libro permite inicializar los atributos de la clase, por ello
recibe el código del libro, el nombre, la cantidad de existencias y el género. En
este mismo método se le reserva memoria al arreglo de autores.
public Libro(String codigo, String nombre, int
cantidadDeExistencias, int genero) {
this.codigo=codigo;
this.nombre=nombre;
this.cantidadDeExistencias=cantidadDeExistencias;
this.genero=genero;
misAutores=new Autor[MAXIMO_ACTORES];
}
El método agregarAutor tiene como parámetro un objeto de tipo autor. Antes de
asignar el autor al libro se debe verificar que no se exceda la cantidad de autores
máxima, es decir, 5.
publicvoid agregarAutor(Autor miAutor) {
if(contadorAutores<misAutores.length) {
misAutores[contadorAutores]=miAutor;
contadorAutores++;
}
}
En la clase Préstamo se declaró como atributo el libro y el cliente que va a realizar
la solicitud. En esta clase solo es necesario construir el método constructor, que
lleva dos parámetros, y los respectivos métodos get para cada uno de los atributos
de la clase.
publicclass Prestamo {
//----------------------------------------------------
------------// Atributos
//----------------------------------------------------

------------/**
* Es el libro que se va a prestar
*/
private Libro miLibro;
/**
* Es el cliente al que se le va a prestar el libro */
private Cliente miCliente;
}
Finalmente, se debe construir la clase Biblioteca. En esta clase se han declarado
los siguientes atributos:
publicclass Biblioteca{
//----------------------------------------------------
------------// Atributos
//----------------------------------------------------
------------/**
* Es el arreglo de autores
*/
private Autor[] misAutores;
/**
* Es el arreglo de clientes
*/
private Cliente[] misClientes;
/**
* Es el arreglo de libros
*/
private Libro[] misLibros;
/**
* Es el arreglo de prestamos

*/
private Prestamo[] misPrestamos;
/**
* Es el contador de autores
*/
privateint contadorAutores;
/**
* Es el contador de clientes
*/
privateint contadorClientes;
/**
* Es el contador de libros
*/
privateint contadorLibros; /**
* Es el contador de prestamos
*/
privateint contadorPrestamos;
//----------------------------------------------------
//----------------------------------------------------
------------publicstaticfinalintMAXIMO=100;
}
ACTIVIDAD
Acontinuación se muestran algunos de los métodos más relevantes de la clase
Biblioteca. Rellene los métodos que así lo requieran.
El método buscarCliente recibe el código del cliente y recorre el arreglo de clientes
en su búsqueda.
public Cliente buscarCliente(String codigo) {
for(int i=0; i<contadorClientes; i++) {
if(misClientes[i].getCodigo().equals(codigo)) return

misClientes[i];
}
returnnull; }
/**
* Este método permite agregar un cliente, para ello se
recibe un codigo * y un nombre. Es de anotar que antes
de agregar se verifica que el * cliente no exista en
el sistema, porque no pueden haber clientes con * el
mismo codigo, para ello se hace uso del método
buscarCliente. En * caso de que buscarCliente retorne
null es porque el cliente no existe, * de lo contrario
se retorna el cliente encontrado
* @param codigo El código del cliente, codigo!=null
* @param nombre El nombre del cliente, nombre!=null
* @return true en caso de que el cliente se agregue
satisfactoriamente
*/
publicboolean agregarCliente(String codigo, String
nombre)
{
if(buscarCliente(codigo)==null&&
contadorClientes<MAXIMO) {
}
returnfalse;
El método asignarAutorLibro recibe la posición del autor dentro del arreglo de
autores, con dicha posición obtiene el autor y se lo asigna al último libro.
publicvoid asignarAutorLibro(int i) {
Autor miAutor=misAutores[i];

misLibros[contadorLibros-1].agregarAutor(miAutor);
}
/**
* Permite listar todos los autores de un libro
* @param posicion Es la posicion en la cual está
ubicada el libro dentro * del array de Libros
* @return un array de String con el listado de autores
del libro
*/
public String[] listarAutoresLibro(int posicion)
{
String salida[]=new String[5]; Libro
miLibro=misLibros[posicion];
for(int i=0; i< miLibro.getContadorAutores();i++) {
} return salida; }
/**
* Permite listar los libros que un usuario tiene
prestados * @param posicion La posicion del usuario
dentro del array de usuarios * @return un array de
string con el listado de los libros */
public String[] listarLibrosPrestadosPorUsuario(int
posicion) {
Cliente miCliente=misClientes[posicion]; String
prestados[]=new String[100]; int contador=0;
for(int i=0; i<contadorPrestamos; i++) {
}
return prestados; }

devolverCantidadExistenciasPrestadasPorLibro permite devolver la cantidad de
existencias prestadas que hay de un libro. Con un for se recorre el array de
préstamos y se busca el libro si lo encuentra se debe contar. Al final se devuelve
el contador.
publicint
devolverCantidadExistenciasPrestadasPorLibro(String
codigo) {
int contador=0;
for(int i=0; i<contadorPrestamos; i++)
{
if(misPrestamos[i].getMiLibro().getCodigo().equals(cod
{
contador++;
}
}
return contador; }
El método prestarLibro recibe la posición del libro y la posición del cliente para
poder realizar el préstamo.
/**
* Permite prestar una libro
* @param posicionL La posicion del libro dentro del
arreglo de libros * @param posicionCliente La posicion
del cliente dentro del array de * clientes
* @return true si se pudo prestar el libro
*/
publicboolean prestarLibro(int posicionL, int
posicionCliente ) {
/*

* Se debe obtener el libro y el cliente, al igual que
la cantidad de * existenciasprestadas por ese libro.
Es importante tener en cuenta que * si solo hay por
ejemplo 3 existencias de ese libro y ya todos están *
prestados no podrá prestar más.
* De igual forma se verifica que ese prestamo no haya
sido efectuado ya, * eso quieredecir que si el cliente
con codigo 123 prestó el libro 45, * entonces este
cliente no podrá volver a prestar ese libro */
Libro miLibro=misLibros[posicionL];
Cliente miCliente=misClientes[posicionCliente];
int
cantidadPrestamos=devolverCantidadExist
if
(cantidadPrestamos<miLibro.getCantidadDeExistencias()&
o(miLibro, miCliente)==false)
{
Prestamo miP = new Prestamo(miLibro, miCliente);
misPrestamos[contadorPrestamos]=miP;
contadorPrestamos++;
verificarInvariante();
returntrue;
}
returnfalse;
/**
* Devuelve el libro mas prestado * @return El libro
mas prestado */

Para resolver este caso de estudio se identificaron los siguientes requisitos
funcionales:
Requisito funcional 1 Nombre
Descripción
Salida
Nombre
Descripción
Entrada
Nombre
Nombre
Salida
Nombre
Salida
Nombre
Salida
Agregar un docente
Se debe permitir agregar un docente al listado general de docentes. Es importante

verificar que el docente no exista en el sistema. 1)código, 2)nombre
Un nuevo docente ha sido agregado
Agregar un grupo
Se debe permitir agregar un grupo al listado general. Es importante verificar que el
grupo no exista ya en el sistema.
1) numero,2) nombre del Grupo,3) código del líder del grupo,4)el listado de
integrantes del grupo
Un nuevo grupo ha sido agregado
Asignar un producto a un grupo
Se debe permitir asignar un producto a un grupo
1)La posición del grupo dentro del arreglo de grupos, 2) el tipo de producto ,3) El
código del grupo, 4) el listado de docentes que crearon el producto
Un nuevo producto se le asigna al grupo
Listar todos los grupos
Se debe generar un listado con la totalidad de grupos
Ninguna
El listado de grupos
Listar productos de un grupo
Se debe permitir el listado de productos de un determinado grupo 1) La posición
del grupo dentro del arreglo de grupos
El listado de productos del grupo indicado
Listar todos los docentes
Se debe permitir listar todos los docentes que hay en la universidad Ninguna
El listado de docentes
Se pueden identificar diferentes entidades: Universidad, GrupoDeInvestigacion,
Docente y Producto.

También es necesario un método constructor, los correspondientes métodos get
para cada uno de los atributosy el método toString.
{
return " Código: "+codigo+" Nombre: "+ nombre; }
La clase GrupoDeInvestigacion tiene entre otros los siguientes métodos:
El método agregarProducto tiene 4 parámetros, a saber: el tipo, el codigo y el
listado de docentes que crearon el producto. Antes de agregar el producto se debe
verificar que no se exceda el máximo de productos, es decir, 100.
publicvoid agregarProducto(int tipo, String codigo,
Docente misDocentes[] ) {
if(contadorProductos<MAXIMO)
{
Producto aux=new Producto(tipo,codigo,misDocentes);
misProductos[contadorProductos]=aux;
contadorProductos++;
}
}
El método agregarIntegranteGrupo se encarga de agregar un nuevo integrante al
grupo. Es importante verificar que dicho docente ya no existe en el grupo, con el
objetivo de evitar repeticiones.
publicvoid agregarIntegranteGrupo(Docente
miIntegrante) {
if(buscarDocente(miIntegrante.getCodigo(),misIntegrante
{
for (int i=0; i<misIntegrantes.length;i++) {
if(misIntegrantes[i]==null) {

misIntegrantes[i]=miIntegrante; }
}
} }
El método devolverProductosGrupo() devuelve el listado de productos del grupo.
public String[] devolverProductosGrupo()
{
//Se recorre el arreglo de misProductos y se verifica
si en esa posición //hay producto, en tal caso se
agrega al arreglo productos la //representación en
String de dicho producto
String productos[]=new String[MAXIMO];
return productos; }
Por otro lado, de la clase Producto los atributos son los siguientes:
//----------------------------------------------------
------------// Atributos
//----------------------------------------------------
------------/**
* Es el tipo del producto. Puede ser articulo (1) o
libro (0) */
privateint tipo;
/**
* Es el código del producto
*/
private String codigo;
/**
* Es el listado de docentes que crearon el producto

*/
private Docente misDocentes[];
}
El constructor de la clase Producto permite inicializar los 3 atributos de la clase.
public Producto(int tipo, String codigo,Docente
misDocentes[]) {
this.misDocentes=misDocentes;
this.tipo=tipo;
this.codigo=codigo;
}
El método listarAutores Devuelve un String con el listado de autores.
public String listarAutores() {
String s="";
for(int i=0; i<misDocentes.length;i++)
{
if(misDocentes[i]!=null)
s+=misDocentes[i].getNombre()+" , "; }
return s;
}
Para finalizar la solución de este caso de estudio se debe construir la clase
Universidad. Sus atributos se muestran a continuación:
publicclass Universidad {
//----------------------------------------------------
------------// Atributos
//----------------------------------------------------
------------/**
* Es el listado de grupos de investigacion

*/
private GrupoDeInvestigacion
misGruposDeInvestigacion[]; /**
* Es el listado general de docentes
*/
private Docente misDocentesGeneral[];
//----------------------------------------------------
//----------------------------------------------------
------------/**
* Es la constante para manejar el número máximo de
docentes y grupos */
privatestaticfinalintMAXIMO=100;
}
Se destacan los siguientes métodos:
El método agregar docente se encarga de insertar un nuevo docente en el arreglo
de general de docentes. Tiene dos parámetros el código y el nombre.
publicint agregarDocente(String codigo, String nombre)
{
int pos=GrupoDeInvestigacion.buscarDocente(codigo,
misDocentesGeneral); if(pos==-1)
{
for (int i=0; i<misDocentesGeneral.length;i++) {
if(misDocentesGeneral[i]==null) {
misDocentesGeneral[i]=new Docente(codigo, nombre);
return i;
}

}
}
return -1;
}
El método buscarGrupo recibe el código del grupo que se desea hallar. Debe
recorrer el arreglo de grupos en su búsqueda. En caso de encontrarlo devuelve la
posición donde está, de lo contrario retorna -1.
publicint buscarGrupo(int numero) {
}
El método agregarGrupo recibe la información necesaria para crear un nuevo grupo
de investigación, a saber: el número del grupo, el nombre, el código del líder y un
arreglo con las posiciones dentro del array de docentes de las personas que van a
incorporarse.
publicint agregarGrupo(int numero,String
nombreGrupo,String codigoLid,int integrantes[])
{
int posicionEnArregloDelGrupo=0;
int
posicionLiderEnArregloGeneral=GrupoDeInvestigacion.bus
misDocentesGeneral);
Docente misDocentesDelGrupo[]=new
Docente[integrantes.length];
for(int i=0; i<misDocentesDelGrupo.length; i++)
{
misDocentesDelGrupo[i]=misDocentesGeneral[integrantes[
if(misDocentesDelGrupo[i].getCodigo().equals(misDocente
regloGeneral].getCodigo()))
{

posicionEnArregloDelGrupo=i;
}
}
GrupoDeInvestigacion miGrupo= new
GrupoDeInvestigacion();
miGrupo.setMisIntegrantes(misDocentesDelGrupo);
miGrupo.setNombreGrupo(nombreGrupo);
miGrupo.setNumero(numero);
miGrupo.setPosicionLider(posicionEnArregloDelGrupo);
if (buscarGrupo(numero)==-1)
{
for(int i=0; i<misGruposDeInvestigacion.length;i++) {
if(misGruposDeInvestigacion[i]==null) {
misGruposDeInvestigacion[i]=miGrupo; return i;
}
}
}
return -1;
}
Finalmente, el método agregarProductoAGrupo recibe la posicion del grupo al cual
se le asignará, ya sea el libro o el artículo, además del listado de integrantes que
elaboró el producto.
publicvoid agregarProductoAGrupo(int posGrupo, int
tipo, String codigo, int integrantes[])
{
Docente misDocentesDelGrupo[]=new
Docente[integrantes.length]; for(int i=0;
i<misDocentesDelGrupo.length; i++)

{
misDocentesDelGrupo[i]=misDocentesGeneral[integrantes[
}
Producto miProducto=new Producto(tipo, codigo,
misDocentesDelGrupo);
misGruposDeInvestigacion[posGrupo].agregarProducto(tipo
codigo, misDocentesDelGrupo);
}
ESTRUCTURAS CONTENEDORAS DE TAMAÑO VARIABLE
1 Objetivos
Al finalizar la unidad el estudiante estará en capacidad de:
Utilizar estructuras contenedoras de tamaño variable para resolver problemas en
los cuales es necesario almacenar una secuencia de elementos cuya cantidad no
se conoce con anterioridad.
Utilizar ciclos para poder manipular las estructuras contenedoras variables
2 Motivación
Algunas veces se requiere resolver problemas en los cuales es necesario
almacenar una secuencia de elementos, pero no se sabe cuántos. Esta
característica obviamente debe verse reflejada en el diagrama de clases. Además,
al momento de plantear la solución, ese grupo de elementos se debe materializar,
es aquí en donde el aplica el concepto de ArrayList.
3 Caso de estudio N.1 Conjuntos (Código Fuente:
unidadIICaso01Conjuntos)
Se requiere de una aplicación que permita realizar las operaciones de intersección
y unión entre varios conjuntos. Se debe permitir también que se eliminen todos los
conjuntos que se han agregado hasta el momento. El resultado de las operaciones
de unión e intersección se deben mostrar ordenados alfabéticamente.

Salida
Nombre
Descripción
Entrada
Salida
Nombre
Descripción
Entrada Salida
Hallar la intersección entre varios conjuntos
Se debe hallar la intersección entre todos los conjuntos que el usuario haya
ingresado hasta el momento. La intersección consiste en encontrar los elementos
que son comunes en todos los conjuntos.
Ninguna
Un nuevo conjunto con el resultado de la intersección
Hallar la unión entre varios conjuntos
Se debe hallar la unión entre todos los conjuntos que el usuario haya ingresado
hasta el momento.
Ninguna
Un nuevo conjunto con el resultado de la unión
Ordenar alfabéticamente los elementos de un conjunto
Se recibe un conjunto y se aplica un método de ordenamiento para lograr que los
elementos queden ubicados de menor a mayor Un conjunto
El conjunto ordenado
Eliminar los conjuntos
Se debe permitir borrar todos los conjuntos que se han ingresado hasta el
momento
Ninguna
Los conjuntos han sido eliminados

Se pueden identificar diferentes entidades: GrupoConjunto y Conjunto.

3.3 Diseño y construcción de la solución del problema
Este caso de estudio requiere de la utilización de estructuras contenedoras de
tamaño variable, en la cuales no se requiere que se conozca su tamaño máximo
tal como ocurre en los arreglos, pues crece o disminuye dinámicamente.
En Java existen varias clases que permiten crear este tipo de estructuras, entre
ellas la clase Vector o la clase ArrayList. En este documento se hará uso de la
segunda.
Cuando se debe representar en el diagrama de clases este tipo de asociaciones
se coloca como cardinalidad los símbolos 0…* para aclarar que su tamaño puede
variar.
Todo ArrayList debe declararse y se le debe reservar memoria. Tal como se
private ArrayList <Conjunto> misConjuntos ;
public GrupoConjunto()
{
misConjuntos=new ArrayList<Conjunto>();
}
En la clase GrupoConjunto se declara un Vector donde cada elemento corresponde
a un conjunto. Para que esto sea posible es necesario importar el paquete
java.util.*;
Observe que al momento de reservarle memoria no fue necesario indicar la
cantidad de elementos que iba a contener. Esto quiere decir, que automáticamente
se arranca con 0 elementos dentro de él. No obstante, ArrayList también brinda la
posibilidad de definir un tamaño inicial:
misConjuntos=new ArrayList<Conjunto>(9);
En este caso se ha creado un ArrayList con un tamaño inicial de 9. Algunos de los

métodos más importantes de los ArrayList son:
size(): Devuelve la cantidad de elementos que hay en la estructura
isEmpty(): Devuelve true si no hay elementos en el ArrayList, de lo contrario
devuelve false.
add(elemento): permite agregar al final de la estructura contenedora un nuevo
elemento.
add(posición, elemento): permite agregar un elemento en la posición indicada. Si
ya había un elemento en esa posición, el elemento que ya existe y todos los que
se encuentran a su derecha se correrán una posición hacia la derecha.
set(posición, elemento): Permite reemplazar el elemento que se encuentra en la
posición por un nuevo elemento.
remove (posición): borra el elemento que está en la posición indicada, esto implica
que los elementos que estaban a la derecha del elemento eliminado se correrán
hacia la izquierda para ocupar el lugar eliminado. Esta operación hace que el
tamaño de la estructura se reduzca en 1. remove(elemento): en este caso se envía
el objeto que se desea eliminar. Es importante aclarar, que si se crea un nuevo
elemento con los datos del objeto que se desea eliminar no indica que sea el
mismo elemento. Para que sean iguales deben ocupar la misma posición de
memoria, es decir, deben ser la mismas instancia.
contains(elemento): Devuelve true si el elemento exist, de lo contrario devuelve
false.
toArray().Copia los elementos que tiene el ArrayList a un arreglo de objetos.
Partiendo del diagrama de clases anterior se iniciará con la construcción de las
clases del paquete mundo.
Primero se mostrarán los atributos de la clase conjunto.
publicclass Conjunto
{

//----------------------------------------------------
------------// Atributos
//----------------------------------------------------
------------/**
* Son los elementos que forman parte del conjunto
*/
private ArrayList <String> misElementos;
}
La clase Conjunto tiene dos métodos constructores. El primero de ellos no tiene
parámetros. Su objetivo es reservarle memoria al ArrayList de elementos del
conjunto.
public Conjunto()
{
misElementos=new ArrayList<String>();
}
El segundo, recibe un ArrayList con los elementos del conjunto.
public Conjunto(ArrayList<String> misElementos) {
this.misElementos = misElementos;
}
Observe que hay dos constructores, el primero de ellos permite reservarle memoria
al Arraylist, surgiendo entonces un conjunto con cero elementos. En el segundo
constructorse reciben los elementos del conjunto por parámetro.
public Conjunto(ArrayList<String> misElementos)
Finalmente el método toString() devuelve un String con la representación del
conjunto.

{
return misElementos.toString(); }
Por otra parte, en la clase GrupoConjuntos se encuentran, entre otros, los
siguientes atributos.
publicclass GrupoConjunto
{
//----------------------------------------------------
------------//Atributos
//----------------------------------------------------
------------/**
* Es el arreglo de conjuntos
*/
private ArrayList <Conjunto> misConjuntos ;
}
El método inicializar(ArrayList <ArrayList<String>> arreglo ) recibe por parámetro un
ArrayList de un ArrayList de String, esto quiere decir, que se tendrá un ArrayList
general llamado arreglo, que en la posición cero almacenará otro ArrayList de
String (correspondiente al primer conjunto que ingresó el usuario). En la posiión 1,
tendrá otro ArrayList con todos los elementos del segundo conjunto y así
sucesivamente.
El método publicvoid inicializar(ArrayList <ArrayList<String>> arreglo) se encarga
de convertir los elementos que hay en la posición cero del arrayList que recibe en
un nuevo conjunto, los elementos que hay en la posición 1 en un nuevo conjunto y
así continúa hasta que recorra todo el ArrayList. Este objetivo se logra a través de
las siguientes instrucciones:
for(int i=0; i<arreglo.size(); i++)

{
misConjuntos add(new Conjunto(arreglo.get(i)));
}
publicvoid inicializar(ArrayList <ArrayList<String>>
arreglo ) {
misConjuntos=new ArrayList<Conjunto>(); for(int i=0;
i<arreglo.size(); i++)
{
misConjuntos.add(new Conjunto(arreglo.get(i)));
} }
El método public Conjunto ordenarAlfabeticamente(Conjunto miConjunto)aplica el
técnica de ordenamiento de Burbuja para ordenar ascendentemente los elementos
del conjunto.
public Conjunto ordenarAlfabeticamente(Conjunto
miConjunto) {//Se aplica burbuja para ordenar
ArrayList<String>
auxiliar=miConjunto.getMisElementos(); for(int i=0;
i<auxiliar.size();i++)
{
for(int j=0; j<auxiliar.size()-1;j++)
{ if(auxiliar.get(j).compareTo(auxiliar.get(j+1))>0) {
String aux=auxiliar.get(j);
auxiliar.set(j,auxiliar.get(j+1)); auxiliar.set(j+1,
aux);
}
}
}

returnnew Conjunto(auxiliar); }
Para entender como funciona este algoritmo imagine que se tiene un arreglo cuyos
elementos son: 66 39 4 35 y 2 y que se ordenará siguiendo la estrategia mostrada
en la siguiente tabla.
66 39 4 35 2
39 66 4 35 2
39 4 66 35 2
39 4 35 66 2
39 4 35 2 66
4 39 35 2 66
4 35 39 2 66
4 35 2 39 66
4 35 2 39 66
4 2 35 39 66
4 2 35 39 66
4 2 35 39 66
2 4 35 39 66
2 4 35 39 66
2 4 35 39 66
2 4 35 39 66 Se puede observar que lo que se ha hecho es desplazar los
elementos más pequeños hacia el inicio del arreglo (hacia el primer elemento) y
los elementos mayores se movieron hacia el fondo del arreglo. Generalizando, lo
que se hizo es tomar el elemento mayor, el cual se fue recorriendo de posición en
posición hasta ponerlo en su lugar. Aeste método de ordenamiento se le conoce
como Burbuja.
Es importante anotar, que existen otros métodos de ordenamiento, entre ellos se
destacan el método de inserción directa y el método de selección.

El método de Inserción directa se basa en tomar uno por uno los elementos de un
arreglo y recorrerlo hacia su posición con respecto a los anteriormente ordenados.
Así empieza con el segundo elemento y lo ordena con respecto al primero. Luego
sigue con el tercero y lo coloca en su posición ordenada con respecto a los dos
anteriores, así sucesivamente hasta recorrer todas las posiciones del arreglo.
Otro método muy conocido es el de Selección, el cual consiste en encontrar el
menor de todos los elementos del arreglo e intercambiarlo con el que está en la
primera posición. Luego el segundo más pequeño, y así sucesivamente hasta
ordenar todo el arreglo.
Por otra parte, el método public ConjuntohallarUnion(), crea un ArrayList de String
en el cual se incluyen todos los elementos de todos los conjuntos verificando que
no se presenten repeticiones.
public Conjunto hallarUnion()
{
ArrayList<String> resultado=new ArrayList<String>();
for (int i=0; i<misConjuntos.size(); i++)
{
for(int
j=0;j<misConjuntos.get(i).getMisElementos().size();j++
{
String
dato=misConjuntos.get(i).getMisElementos().get(j);
if(!resultado.contains(dato))
resultado.add(dato);
}
}
returnnew Conjunto(resultado);

}
Para el método hallarInterseccion() se require de 3 for. El primero de ellos recorre
cada uno de los elementos del conjunto cero. Através del segundo for se obtienen
todos los conjuntos (diferentes al conjunto cero) y con el tercer for, se recorren los
elementos de cada uno de esos conjuntos. La idea general consiste en que cada
elemento obtenido del conjunto cero debe compararse con cada uno de los
elementos que hay en cada conjunto. Si al final se determina que un elemento del
conjunto cero, está presente en todos los demás conjuntos, ese elemento se
selecciona y se agrega al resultado.
public Conjunto hallarInterseccion()
{
int k, j,l;
ArrayList <String> misElementos=new ArrayList<String>
();
String elemento="", elemento1="";
/*Se obtiene el conjunto 0 del conjunto 0 se obtiene
cada uno de sus elementos es decir, se obtiene el
elemento j*/
for(j=0;j<misConjuntos.get(0).getMisElementos().size()
{
elemento=misConjuntos.get(0).getMisElementos().get(j);
/*El elemento obtenido debe compararse con cada uno de
los elementos que hay en
cada conjunto. Por lo tanto se toma cada uno de los
conjuntos que son diferentes
al conjunto 0 y se saca cada uno de los elementos para
luego comparse con el
elemento del conjunto 0*/
int contador=0;

for(k=1; k<misConjuntos.size(); k++)
{
for(l=0;
l<misConjuntos.get(k).getMisElementos().size(); l++)
{
elemento1=misConjuntos.get(k).getMisElementos().get(l)
if(elemento.equals (elemento1))
{ contador++; }
}
}
//si hay 4 conjuntos entonces el elemento comparado
debe estar repetido 3 //veces
if(contador==misConjuntos.size()-1)
{ String
elem=misConjuntos.get(0).getMisElementos().get(j);
if(!misElementos.contains(elem))
misElementos.add(elem);
}
}
returnnew Conjunto(misElementos);
}
}
4 Caso de estudio N.2 Conjunto Cerrado (Código
Fuente:unidadIICaso02ConjuntoCerrado)
Se desea crear una aplicación para manejar la información de un conjunto cerrado.
El conjunto cerrado tiene 55 casas, de las cuales las primeras 35 deben pagar
142000 por concepto de administración (pues son casas de dos plantas), las
restantes deben pagar este mismo valor incrementado en un 10% ( son casas de
tres plantas). Cada casa tiene un listado de habitantes, un número y una cantidad
de pisos. Cuando una persona compra una casa, por cada habitante se registra el

nombre, la identificación, la edad y un tipo. En el caso de los niños menores de 13
años la administración solicita al propietario de la vivienda que informe si el menor
puede salir o no del conjunto.
La aplicación debe permitir adicionalmente mostrar el listado de propietarios de
viviendas y la cantidad de niños autorizados a salir del conjunto, también el total
recaudado en administración.

Nombre
Descripción
Entrada Salida
Registrar una persona en una determinada casa
Se debe registrar una persona, para ello se ingresan sus datos personales y se
indica si es o no el propietario. Si la persona es menor de 13 años el propietario
debe informar si el niño puede salir del conjunto sin la compañía de un adulto.
1)el número de la casa en la que habitará la persona
2)nombre3)identificacion,4)autorización a salir 5) indicar si es propietario5)edad
La persona ha sido registrada
Listar todos los propietarios del conjunto
Se debe recorrer el listado de casas y por cada una de ellas sacar el propietario.
Ninguna
La lista de propietarios
Calcular el total recaudado en administración
Para calcular el total recaudado en administración se debe tener en cuenta que las
primeras 35 deben pagar 142000 por concepto de administración, las restantes
deben pagar este mismo valor incrementado en un 10% . Si la casa no tiene
propietario, es decir, aún pertenece a la constructora no debe pagar administración.
Ninguna
El total recaudado por concepto de administración
Las clases identificadas son: ConjuntoCerrado, Casa, Habitante

//----------------------------------------------------
//----------------------------------------------------
------------/**
* Es el valor de la cuota de administración
*/
privatefinalstaticdoubleVALOR=142000;
}
En el método constructor se le reserva memoria al ArrayList de Habitantes y se
indica la cantidad de pisos que tiene la propiedad.
public Casa(int numero) {
this.numero = numero;
misHabitantes=new ArrayList<Habitante>();
cantidadPisos=2;
if(numero<ConjuntoCerrado.TIPO1) {
cantidadPisos=3; }
}
El método agregar tiene varios parámetros String nombre, String identificacion,
boolean autorizacionSalir, boolean propietario,int edad. Através de ellos es posible
crear el nuevo habitante que luego será agregado al ArrayList de habitantes.
publicvoid agregarHabitante(String nombre, String
identificacion, boolean autorizacionSalir, boolean
propietario,int edad)
{
misHabitantes.add( new Habitante(nombre,
identificacion, autorizacionSalir, propietario,
edad));
}

El método calcularValorAPagarAdministracion verifica el número de la casa, si es
menor de 35, entonces informa que debe pagar 142000, de lo contrario le aumenta
un 10% a este valor. No se le cobra administración a viviendas que no tienen
propietario, pues siguen siendo propiedad de la constructora.
publicdouble calcularValorAPagarAdministracion() {
if(misHabitantes.size()>0)
{if(numero<ConjuntoCerrado.TIPO1)
{returnVALOR;}
else
{returnVALOR*0.1;}
}
else
return 0; }
Por otro lado, en la clase ConjuntoCerrado se desarrollan métodos como los
siguientes:
Método constructor, en el que se crean la totalidad de casas.
public ConjuntoCerrado()
{
misCasas=new ArrayList<Casa>(); for(int i=0; i<MAXIMO;
i++) {
misCasas.add( new Casa(i+1)); }
}
El método informarCantidadNinosAutorizados recorre el ArrayList de casas y por
cada casa el ArrayList de habitantes y verifica si el habitante es menor de 13 años
y si está autorizado a salir. Si esto es verdadero incrementa el contador.
publicint informarCantidadNinosAutorizados()

{
int contador=0;
for(int i=0; i<misCasas.size();i++)
{
for(int j=0;
j<misCasas.get(i).getMisHabitantes().size(); j++)
{
if(misCasas.get(i).getMisHabitantes().get(j).getEdad()
<13&&
misCasas.get(i).getMisHabitantes().get(j).isAutorizacio
contador++;
}
}
return contador;
}
El método calcularTotalAdministracion recorre el ArrayList de casas y acumula el
valor que se debe pagar por cada casa en la variable acum.
publicdouble calcularTotalAdministracion()
{double acum=0;
for(int i=0; i<misCasas.size();i++)
{
acum+=misCasas.get(i).calcularValorAPagarAdministracion
}
return acum;
}
5 Caso de estudio N.1 El Avión (Código Fuente: unidadIIHoja01Avion)
Se desea crear una aplicación para manejar la información de un avión. El usuario
de la aplicación deberá informar inicialmente cuantas filas y columnas están

presentes en el avión. Se aceptarán valores entre 6 y 11 para las columnas y entre
4 y 14 para las filas.
La aplicación debe permitir sentar a un pasajero indicando su información básica,
su ubicación y clase de preferencia. Las posibles ubicaciones son Centro y
Ventana y las posibles clases son Económica y Ejecutiva. La clase ejecutiva
corresponde a los puestos ubicados en la diagonal principal y secundaria en las
primeras 4 filas. En el avión siempre habrá una zona inactiva que corresponde a
los elementos que se encuentran entre la diagonal principal y secundaria en las
cuatro primeras filas.Todos los demás puestos corresponden a ubicación
económica.
Es muy importante que se conserve el registro de todos los pasajeros que se han
sentado en cada una de las sillas.
También se debe permitir eliminar un pasajero indicando su cédula y consultar la
información de un pasajero indicando su posición.

Salida
Nombre
Descripción
Entrada Salida
Ubicar un pasajero
El pasajero llega a la aeropuerto y da sus datos personales y preferencias en torno
a clase y ubicación
1)cedula, 2)nombre, 3)clase, 4)ubicación
El pasajero ha sido ubicado
Cancelar la reservación de un pasajero
Para cancelar la reservación de un pasajero se debe solicitar la cédula
La cédula
La reservación ha sido cancelada
Consultar la información de un pasajero
Para consultar la información de un pasajero se debe informar la posición en la
cual está ubicado
La posición
El pasajero que está ubicada en dicha posición
Se pueden identificar diferentes entidades: Avión, Puesto y Persona

/**
* Es la cedula de la persona
*/
private String cedula;
}
En esta clase se requiere de un constructor y los correspondientes
métodos get y set.
En la clase Puesto, además de los métodos get y set para número, clase,
ubicación y estado se cuenta con los siguientes:
- El método Constructor permite inicializar los atributos número y estado y
reservarle memoria al ArrayList de personas.
public Puesto(int numero, int estado) { this.numero =
numero;
this.estado=estado;
misPersonas=new ArrayList<Persona>();
}
- El método agregarPersona tiene como parámetros el nombre y la cédula. Con
estos datos se crea la persona que se va a agregar al ArrayList. Luego de agregar
una persona la variable estado se pone en 1.
publicvoid agregarPersona(String nombre, String
cedula) { Persona miPersona = new
Persona(nombre,cedula); misPersonas.add(miPersona);
estado=1;
}
- Para eliminar una persona sólo se pone el estado en cero. No se elimina
físicamente puesto que se solicitó conservar el resgistro de todos los clientes que

se han ubicado en los puestos.
publicvoid eliminarUltimaPersona()
{
estado=0;
}
Finalmente, algunos de los métodos de la clase Avion son:
El método constructor del Avión. En éste se le reserva memoria al ArrayList y a
cada uno de los Puestos. Es importante ir colocando la clase y la ubicación a
cada puesto a mediad que se van creando.
Observe que la clase se le asignó a cada puesto a través de una enumeración. Tal
como se muestra a continuación:
/*Aqui se crean todas las sillas que están en
mantenimiento*/ for(int i=0; i<inicio.size(); i++)
{
for(int j=inicio.get(i)+1; j< finaliza.get(i); j++) {
misPuestos.get(j).setClase(Clase.MANTENIMIENTO.getNumC
}
}
public Avion(int filas,int columnas) {
misPuestos=new ArrayList<Puesto>(); for(int i=0; i<
columnas*filas; i++) {
Puesto miPuesto=new Puesto(i,0);
misPuestos.add(miPuesto);
}
ArrayList<Integer> inicio= new ArrayList<Integer>();

ArrayList<Integer> finaliza=new ArrayList<Integer>();
int izq=columnas+1;
int derecha=columnas-1;
/*Aqui se crean todos los puestos de clase ejecutiva y
se capturan todas las posiciones para poder crear las
sillas inactivas*/
for(int i=0; i<4;i++)
{
inicio.add(i*izq);
finaliza.add(derecha*(i+1));
misPuestos.get(i*izq).setClase(Clase.EJECUTIVA.getNumC
misPuestos.get(derecha*
(i+1)).setClase(Clase.EJECUTIVA.getNumClase()); }
/*Aqui se crean todas las sillas que están en
mantenimiento*/
for(int i=0; i<inicio.size(); i++)
{
for(int j=inicio.get(i)+1; j< finaliza.get(i); j++)
{
misPuestos.get(j).setClase(Clase.MANTENIMIENTO.getNumC
}
}
/*No es necesario ponerle clase a las que falta, pues
por defecto se inicializaron con tipo 0 que es
económica. Ahora se fijan las ventanas. No es
necesario fijar el centro pues por defecto se
inicializó con cero. */
for(int i=0; i<=filas*columnas-columnas; i+=columnas )
{
misPuestos.get(i).setUbicacion(Ubicacion.VENTANA.getNum
misPuestos.get(i+columnas-
1).setUbicacion(Ubicacion.VENTANA.getNumUbicacion());

}
}
El método ubicarPasajero se encarga de ubicar un pasajero en un puesto acorde a
las preferencias expresadas con respecto a la clase y la ubicación. Si el pasajero
ya existe, no puede ubicarse nuevamente en el avión.
publicint ubicarPasajero(String nombre, String cedula,
int numUbicacion, int numClase)
{
if(buscarPasajero(cedula)==-1)
{
for(int i=0; i< misPuestos.size(); i++)
{
if(misPuestos.get(i).getEstado()==0&&misPuestos.get(i)
on&&misPuestos.get(i).getClase()==numClase)
{
misPuestos.get(i).agregarPersona(nombre, cedula);
return i;
}
}
}
return -1;}
5.4 Enum como nuevo elementos de modelado
Un nuevo elemento de modelado que se incorpora en este caso de estudio es el
enum. Un enum se utiliza para limitar el contenido de una variable a una lista de
valores definidos con anterioridad. Un tipo enumerado es una instancia del tipo
enumerado del cual se declaró. No se puede considerar como un String o un
entero.

publicenum Clase {
//Clases de puestos
EJECUTIVA (1), ECONOMICA(0), MANTENIMIENTO(2);
privateint numClase;
private Clase(int numClase) { this.numClase =
numClase;
}
publicint getNumClase() { return numClase;
}
publicvoid setNumClase(int numClase) { this.numClase =
numClase;
}
}
Si en un momento dado se requiere imprimir la clase de cada uno de los puestos
que hay en el avión sería posible apoyarnos en esta misma enumeración,
mediante la instrucciónClase.values()[tipo],lo cual se puede interpretar como:
Si tipo toma el valor de cero, entonces Clase. values()[0] devolverá EJECUTIVA, si
toma el valor de 1, Tipo.values()[1] devolverá ECONOMICA, si toma el valor de 2,
Tipo.values()[2] devolverá MANTENIMIENTO.
ACTIVIDAD
Construya un método que genere un listado con la información de todos los
puestos que hay en el Cine. Es importante mostrar como mínimo el número de
puesto, el estado del puesto y la clase del puesto.
Para este caso de estudio también se creó una enumeración para trabajar la
Ubicación del puesto.

publicenum Ubicacion {
//Clases de puestos VENTANA (1), CENTRO(0);
privateint numUbicacion;
private Ubicacion(int numUbicacion) {
this.numUbicacion = numUbicacion;
}
publicint getNumUbicacion() { return numUbicacion;
}
publicvoid setNumUbicacion(int numUbicacion) {
this.numUbicacion = numUbicacion;
}
}
5.5 foreach en Java
En el método buscar pasajero se utilizó la estructura repetitiva for-each, la cual
permite iterar sobre colecciones de objetos.Toda Collection tiene un tamaño y
puede recorrerse para conocer cada uno de los elementos que almacena. En Java
hay clases que manejan colecciones y permiten realizar sus operaciones básicas,
a saber:
add(element): Agrega un elemento.
iterator(): Obtiene un iterador. Un iterador es un objeto a través del cual es posible
ir obteniendo uno a uno los objetos al ir llamando repetitivamente método next().
size(): Devuelve el tamaño de la colección
contains(element): Pregunta si el elemento se encuentra dentro de la colección.
Un ejemplo del uso de Iterator es el siguiente:

void recorrer(Collection<Puesto> misP) {
Iterator<Puesto> it = misP.iterator();
while(it.hasNext())
{
Puesto miP = it.next(); }
}
Luego de la versión 6 de Java se ofrece una manera muy sencilla de recorrer una
collección, que es sumamente útil en el caso de que no se requiera eliminar
elementos. Esta estructura es el foreach. Tiene la siguiente sintáxis:
for (TipoBase variable: ArrayDeTiposBase) {..}
La utilización de esta estructura se muestra a continuación:
publicint buscarPasajero(String cedula)
{
//Se recorren todos los puestos que hay en el
ArrayList
for(Puesto miPuesto: misPuestos)
{
//Por cada puesto se verifica que haya persona y que
la cedula de dicha persona //coincida con la cédula de
la persona buscada
if(miPuesto.getMisPersonas().size()>0&&miPuesto.getMis
MisPersonas().size()-1).getCedula().equals(cedula)&&mi
{
return miPuesto.getNumero();
}
}
return -1;
}

Para resolver este caso de estudio se identificaron los siguientes requisitos
funcionales:
Requisito funcional 1 Nombre
Descripción
Salida
Nombre
Nombre
Salida
Nombre
Descripción
Entrada
Salida Registrar un nuevo cliente
Se debe registrar un nuevo cliente, para ellos se debe solicitar el código y el
nombre. No se podrán registrar clientes que ya existan en el sistema.
1)código, 2)nombre
Un nuevo cliente ha sido registrado
Agregar una nueva cuenta
Se debe permitir registrar una nueva cuenta
1)número de la cuenta, 2)el monto, 3)el tipo de cuenta (ahorro o corriente), 4)La
posición donde se encuentra ubicado el cliente al cual se le va a crear la cuenta
Se ha creado una nueva cuenta

Programación orientada a objetos sergio augusto cardona torres

Programación orientada a objetos sergio augusto cardona torres

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (11)

Destacado

Destacado (15)

Similar a Programación orientada a objetos sergio augusto cardona torres

Similar a Programación orientada a objetos sergio augusto cardona torres (20)

Más de Alejandro Garces

Más de Alejandro Garces (9)

Último

Último (20)

Programación orientada a objetos sergio augusto cardona torres