Embed Size (px)
Citation preview
Programación Orientada a ObjetosEste libro está inspirado en el proyecto CUPI2, realizado por la Universidad de losAndes, cuyo principal propósito es encontrar mejores formas de enseñar/aprendera resolver problemas haciendo uso de un lenguaje de programación
Sonia Jar amillo Valbuena Adscrito alPrograma de Ingeniería de Sistemas y Computación Facultad de IngenieríaUniversidad del Quindío
Ser gio Augusto Car dona Tor r es Adscrito alPrograma de Ingeniería de Sistemas y Computación Facultad de IngenieríaUniversidad del Quindío
Leonar do Alonso Her nández Rodr íguez Adscrito alPrograma de Ingeniería de Sistemas y Computación Facultad de IngenieríaUniversidad del Quindío
Programación Orientada a ObjetosNo está permitida la reproducción total o parcial de esta obra, ni su tratamiento otransmisión por cualquier método sin autorización escrita deleditor.
Derechos reservadosISBN: 978-958-44-7914-3 200 ejemplares
©Derechos reservadosReproducido y editado por Ediciones Elizcom Primera edición, diciembre del 2010200 [email protected] : 57 +6 +7450655Móvil: 57 +3113349748Armenia, QuindíoColombia
PROGRAMACIÓN ORIENTADA A OBJETOS CONTENIDOPág.
ESTRUCTURAS CONTENEDORAS DE TAMAÑO FIJO..................................................................................... 91Objetivos.......................................................................................................................92Motivación.....................................................................................................................93 Caso de estudio N.1 La Empresa (Código Fuente: unidadICaso01Empresa)............................................ 9
3.1 Comprensión de los requisitos............................................................................................................. 103 2 Comprensión del mundo delproblema................................................................................................. 113 3Arreglos..........................................................................................................................113.4 Recorrer los arreglos........................................................................................................................... 133 5 Patrones para instruccionesrepetitivas................................................................................................ 163.6 El manejo de la memoria en Java........................................................................................................ 183.7 Ex cepciones.......................................................................................................................................183.8 Diseño por contrato............................................................................................................................. 204 Caso de estudio N.2 Cine ElizMark (Código Fuente: unidadICaso02Cine).............................................. 274.1 Comprensión de los requisitos............................................................................................................. 284 2 Comprensión del mundo delproblema................................................................................................. 284 3 Diseño y construcción de la solución del problema.............................................................................. 305 Hoja de trabajo 1 La Biblioteca (Código Fuente:unidadIHoja01Biblioteca).............................................. 365.1 Comprensión de los requisitos............................................................................................................. 37
5 2 Comprensión del mundo delproblema................................................................................................. 375 3 Diseño y construcción de la solución del problema.............................................................................. 396 Hoja de trabajo N.2 Universidad (Código Fuente: unidadIHoja02Universidad)........................................ 456.1 Requisitos funcionales.................................................................................................................... 456 2 Comprensión del mundo delproblema............................................................................................ 466 3 Diseño y construcción de la solución del problema......................................................................... 48ESTRUCTURAS CONTENEDORAS DE TAMAÑOVARIABLE.......................................................................... 531 Objetivos.......................................................................................................................................532 Motivación.......................................................................................................................................533 Caso de estudio N.1 Conjuntos (Código Fuente:unidadIICaso01Conjuntos)............................................... 533.1 Requisitos funcionales.................................................................................................................... 543 2 Comprensión del mundo delproblema............................................................................................ 553 3 Diseño y construcción de la solución del problema......................................................................... 574 Caso de estudio N.2 Conjunto Cerrado (CódigoFuente:unidadIICaso02ConjuntoCerrado)..................... 62
4.1 Requisitos funcionales.................................................................................................................... 634 2 Comprensión del mundo delproblema............................................................................................ 644 3 Diseño y construcción de la solución del problema......................................................................... 655 Caso de estudio N.1 El Avión (Código Fuente: unidadIIHoja01Avion)......................................................... 675.1 Requisitos funcionales.................................................................................................................... 685 2 Comprensión del mundo delproblema............................................................................................ 685 3 Diseño y construcción de la solución del problema......................................................................... 695.4 Enum como nuevo elementos demodelado.................................................................................... 725 5 foreach en Java.............................................................................................................................. 736 Caso de estudio N.1 El Banco (Código Fuente: unidadI Hoja02Banco)................................................... 746.1 Requisitos funcionales.................................................................................................................... 756 2 Comprensión del mundo delproblema............................................................................................ 766 3 Diseño y construcción de la solución del problema......................................................................... 76ARRAYB D MENSIONAL...........................................................................................................811 Objetivos
.......................................................................................................................................812 Motivación.......................................................................................................................................813 Caso de estudio N.1 El cine (Código Fuente: unidadIIICaso01Cine)........................................................... 813.1 Requisitos funcionales.................................................................................................................... 823 2 Comprensión del mundo delproblema............................................................................................ 823 3 Diseño y construcción de la solución del problema......................................................................... 843.4 Patrones para recorrido sobre matrices.......................................................................................... 874 Caso de estudio N.2 El Bingo (Código Fuente: unidadIIICaso02Bingo)....................................................... 883 5 Requisitos funcionales.................................................................................................................... 893.6 Comprensión del mundo delproblema............................................................................................ 903.7 Diseño y construcción de la solución del problema......................................................................... 924 Hoja de Trabajo N.1 El Triqui (Código Fuente:unidadIIIHoja01Triqui)..................................................... 964.1 Requisitos funcionales.................................................................................................................... 974 2 Comprensión del mundo delproblema............................................................................................ 974 3 Diseño y construcción de la solución del problema
......................................................................... 985 Hoja de Trabajo N 2 Concéntrese (Código Fuente: unidadII Hoja02JuegoParejas)............................... 1025.1 Requisitos funcionales.................................................................................................................. 1035 2 Comprensión del mundo delproblema.......................................................................................... 1045 3 Diseño y construcción de la solución del problema....................................................................... 104PERSISTENCIA.......................................................................................................................................1091 Objetivos.......................................................................................................................................1092 Motivación.......................................................................................................................................1093 Caso de estudio N.1 La Empresa (Código Fuente: unidadIVCaso01Empresa).......................................... 1093.1 Requisitos funcionales.................................................................................................................. 1103 2 Comprensión del mundo delproblema.......................................................................................... 1103 3 Diseño y construcción de la solución del problema....................................................................... 1123.4 Archivos.......................................................................................................................................1123 5 Métodos de ordenamiento y búsqueda
......................................................................................... 1163 5 Pruebas desoftware.....................................................................................................................1224 Caso de estudio N.2 La Libreta Telefónica (Código Fuente:unidadIVCaso02LibretaTelefonica) ........... 1294.1 Requisitos funcionales.................................................................................................................. 1304 2 Comprensión del mundo delproblema.......................................................................................... 1314 3 Diseño y construcción de la solución del problema....................................................................... 1314.4 Serializacion.................................................................................................................................1355 Hoja de trabajo N.1 El Ahorcado (Código Fuente: unidadIVHoja01Ahorcado)....................................... 1365.1 Requisitos funcionales.................................................................................................................. 1375 2 Comprensión del mundo delproblema.......................................................................................... 1375 3 Diseño y construcción de la solución del problema....................................................................... 1386 Caso de estudio N.2 La Tienda Paisa (Código Fuente:unidadIVHoja01TiendaPaisa)........................... 1416.1 Requisitos funcionales.................................................................................................................. 1426 2 Comprensión del mundo delproblema.......................................................................................... 1436 3 Diseño y construcción de la solución del problema
....................................................................... 143B BLIOGRAFIA.............................................................................................................147
PREFACIO
El presente libro está inspirado en el proyecto CUPI2 realizado por la Universidadde los Andes, cuyo principal propósito es encontrar mejores formas deenseñar/aprender a resolver problemas haciendo uso de un lenguaje deprogramación.
Para el entendimiento de este libro es necesario contar conconocimientos básicosen:clases y objetos, ex presiones, 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 estructurasrepetitivas para resolver problemas que involucren el uso de estructurascontenedoras estáticas y conocerá los diferentes patrones para recorrer este tipode estructuras. También se familiarizará con la metodología de Diseño por contratoy el manejo de ex cepciones.
2) Estructuras contenedoras de tamaño variable. El lector estará en capacidad deutilizar estructuras repetitivas para resolver problemas que involucren el uso deestructuras contenedoras. Además, conocerá el método de ordenamiento Burbuja ynuevos tipos de estructuras, tales como el foreach y enumeraciones.
3) Arreglos bidimensionales. El lector manejará el concepto de estructurascontenedoras en dos dimensiones y podrá aplicar los diferentes patrones derecorrido.
4) Serialización. El lector adquirirá reforzará su conocimiento respecto aestructuras contenedoras yserá capaz de lograr que la información sea persistente,
para ello se incorporarán los temas de archivosProperties, serialización yGenerics. De igual forma, hará uso de ex cepciones personalizadas que lepermitirán garantizar que la información digitada es correcta.También, seintroducirá el concepto de pruebas con el JUnit. Finalmente se reforzarán losconocimientos con respecto a métodos de ordenamiento y se incorporará elconcepto de búsqueda binaria.
El código fuente de cada uno de los ejemplos desarrollados en este libro seencuentra en el CD anex o. Es de anotar, que todos los proyectos ex plicadoshacen uso de interfaz gráfica.
Para finalizar este prefacio es importante agradecer a la Universidad de losAndespor su importante proyecto CUPI2, pues éste es fuente de inspiración paramuchas universidades y un importante avance para la solución del típico problemade enseñar a programar.
ESTRUCTURAS CONTENEDORAS DE TAMAÑO FIJOObjetivosAl finalizar la unidad el estudiante estará en capacidad de: Utilizar estructuras contenedoras de tamaño fijo para resolver problemas en loscuales 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 quese programe se documente el código y se detecten errores. Utilizar la clase Ex ception para capturar y manipular errores que pueden surgir entiempo de ejecución.Motivación
En algunas ocasiones se requiere resolver problemas en los cuales es necesarioalmacenar una secuencia de elementos, por ejemplo: un listado de estudiantes, deproductos 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ónesegrupo de elementos se debe materializar, es aquí en donde el aplica el conceptode arreglos.
En este capítulo además de los arreglos se estudiarán otras temáticas, talescomo: ciclos, metodología de diseño por contrato y ex cepciones. Estás últimaspermitirán capturar y tratar los errores inesperados que surgen durante la ejecuciónde un programa.
Caso de estudio N.1 La Empr esa (Código Fuente: unidadICaso01Empr esa)
Se desea crear una aplicación para manejar la información de una empresa, en lacual hay 6 empleados. Cada empleado tiene un nombre, un código, una edad y unsalario. 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 deempleados cuyo nombre inicia en la vocal especificada por el usuario, informar lacantidad de empleados con edad superior a 30 e imprimir el salario promedio.
DescripciónRequisito funcional 4
Requisito funcional 5 EntradaSalidaNombreDescripción EntradaSalidaNombreDescripción EntradaSalidaModificar la información del empleadoEl usuario podrá modificar cualquiera de los 4 datos del empleado. 1)El número delempleado al que se le va a modificar la información 2) Los nuevos datos: nombre,código, edad o salarioLa información del empleado ha sido modificadaincrementar en un 10% el salario Se requiere incrementar en un 10% el salario de todos los empleadosNingunaSe ha incrementado el salario a todos los empleadosInformar la cantidad de empleados cuyo nombre inicia en la vocal especificada porel usuarioEl usuario selecciona una de las cinco vocales y la aplicación debe informarcuantos empleados tienen nombre que inicie en dicha vocalLa vocalLa cantidad de empleados con nombre que inicia en esa vocal Informar la cantidadde empleados con edad superior a 30 Se deben contar los empleados que tienenedad superior a 30 NingunaLa cantidad de empleados con edad superior a 30Informar el salario promedio
Se requiere calcular el salario promedio de la empresaNinguna El salario promedio
3.2 Compr ensión del mundo del pr oblemaEl modelo conceptual se puede definir a través de dos clases: Empleado yEmpresa, 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 serunidimensionales, bidimensionales o multidimensionales, pero esta unidad seconcentra en los unidimensionales.
Todo arreglo debe declararse y se le debe reservar memoria para poder serutilizado. 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 sidocreado. Para crear un arreglo se le debe reservar memoria, a través deloperadornew:edades = new int[10];
También es posible iniciar un arreglo al momento de su declaración, ejemplo: intedades[]={4,56,34,13};
Luego de que se reserva memoria Java inicializa los arreglos dependiendo del tipode 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 index ación “ []” . Esteindica que se va a almacenar una lista de elementos del mismo tipo. Gracias aeste operador es posible acceder a cada uno de los elementos almacenados en laestructura 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)) {returntrue;}
Lo anterior significa que si hay un empleado en la posición 2 y el código delempleado 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 delarreglo 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 dereservarle memoria al arreglo será necesario crear cada uno de los objetos que vana almacenar.
Retomando el desarrollo del caso de estudio será necesario entonces declarar unarreglo 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 habermáximo 6 empleados */
public Empresa(){misEmpleados=new Empleado[MAXIMO_EMPLEADOS];}}
3.4 Recor r er los ar r eglosPara 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: Ex presión condicional o Decisión Cuerpo del ciclo: en esta parte se ponen las instrucciones que se desea ejecutarrepetitivamente un cierto número de veces. Salida del ciclo En general, los ciclos se controlan a través de un contador, una variable queaumenta o disminuye su valor en una cantidad fija cada vez que se efectúa larepetición.
También, es común encontrar dentro de los ciclos variables acumuladoras, lascuales permiten almacenar una cantidad variable cada vez que se efectúa unarepetición. Por ejemplo, cuando se requiere realizar una sumatoria o sacar unpromedio.La primera estructura que se analizará será el while. Esta estructura tiene lasiguiente forma:
while ( condición ) {acción 1........acción n}
En este tipo de estructura las acciones se repiten “ mientras” que se cumple unadeterminada 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 elcontrario se finaliza la ejecución del while.
El do-while, es una estructura que permite que las acciones se ejecuten almenosuna 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 lacondición, si ésta da como resultado true nuevamente se repiten las acciones, delo contrario se finaliza el ciclo.La última estructura repetitiva, y la más usada para trabajar con arreglos, es elciclo 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 unaex presión de asignación. La inicialización solo se efectúa una vez. Acontinuación, se evalúa la condición y si da verdadero se ejecuta el cuerpo delciclo. En caso de que de false, el ciclo finaliza.
Luego se efectúa la iteración, que consiste en aumentar o disminuir la variable decontrol del ciclo.
Ahora bien, luego de esta conceptualización se continuará con el desarrollo deeste caso de estudio Para responder a los requisitos funcionales es necesarioconstruir varios métodos, algunos de los cuales se ex plicarán a continuación:
El métodoincrementarEn10() se encarga de aumentar el salario de todos losempleados en un 10% . Este método no requiere de parámetros. El métodofunciona de la siguiente forma: Se crea un ciclo for que inicia en 0 y va hasta lacantidad de empleados. Es importante preguntar en cada posición si se haregistrado un empleado, es decir, si no es null. En caso de que sea así, se llama almé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 cuyonombre inicia en la vocal especificada por el usuario. Este método tiene unparámetro, la vocal. Para poder conocer la cantidad de empleados cuyo nombreinicia en dicha vocal se debe plantear una estructura repetitiva que permita recorrertodo el arreglo y verificar en caso de que ex ista un empleado si su nombre iniciaen esa vocal.
publicint contarVocal(char vocal) {int contador=0; String nombre="";
for (int i=0; i<MAXIMO_EMPLEADOS; i++){if(misEmpleados[i]!=null)
{ 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 quetenga claro, que los códigos de las letras mayúsculas son diferentes a los de lasminúsculas.
En el método anterior se hizo uso del método charAt. Este permite obtener uncaracter 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 laposición 1 la instrucción es nombre.charAt(1), si se necesita la posición i seescribe nombre.charAt(i).El método contarEmpleadosMayores30() permite obtener la cantidad de empleadoscon edad superior a 30. En éste se recorre todo el arreglo y a cada empleadoex istente se le pregunta la edad. En caso de que la edad sea superior a 30 sedebe 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 Patr ones par a instr ucciones r epetitivasUn 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 r ecor r ido Total
Mediante este patrón se tiene acceso a cada una de las posiciones del arreglo, porello es necesario que el índice inicie en cero y se incremente de uno en uno hastallegar a la cantidad de elementos del arreglo-1. También, el índice podría iniciar enla cantidad de elementos del arreglo-1 e ir decrementando de uno en uno hastallegar 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++) {if(misEmpleados[i]!=null){acumulador+=misEmpleados[i].getSalario(); contador++;}}
b) Patr ón de Recor r ido Par c ial
Se recorre el arreglo y por cada elemento se verifica si ya se cumplió la condiciónde finalización del ciclo, es decir, si el problema ya fue resuelto. Por ejemplo, senecesita obtener el primer empleado con edad superior a 35 años, o buscar elempleado cuya cédula es 415. Luego de encontrar el dato requerido no tienesentido seguirse moviendo en el arreglo.
1Estos patrones están descritos en el libro Fundamentos deProgramación. Aprendizaje activo Basado en Casos de JorgeVillalobos 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&¢inela==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 r ecor r idoEn este tipo de patrón por cada elemento del array se realiza un recorridocompleto.
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 arrayedad = 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 delelemento actual con el contador //generalif( contador > guardaContador )
{ guardaContador = contador;mayorFrecuencia = i; }}//Cierra el forreturn misEmpleados[mayorFrecuencia];}
3.6 El manejo de la memor ia en Java
La memoria está dividida en tres zonas, a saber: la Zona de Datos, el Stack oMemoria de pila y el Heap, o Memoria de montículo. En la primera de ellas, sealmacenan las instrucciones del programa, las constantes, los métodosy lasclases. En el Stack se guardan las referencias a objetos (es decir, instanciascreadas 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, sealmacenan los objetos creados. La forma como el heap y el stack interaccionanpuede 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 unaex cepción que es capturada, logrando con ello que la ejecución del programasalte al catch. Dentro del catch se solicita el mensaje del error que ha ocurrido atravé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 ex cepción se escribefinally. El formato general es:
try{…}catch (Exception e) {…}finally{…}
Si el objetivo es generar una ex cepción dentro de un método se utiliza throw.Dichas ex cepciones se definen creando una subclase de Ex ception. Cuandodentro de un método se lanza una ex cepción derivada de Ex ception es necesarioañadir la palabra reservada throws en la cabecera del método seguida de la listade ex cepciones que se pueden producir, ejemplo:
publicboolean agregarEmpleado(int posicion, Stringcodigo, String nombre, int horasTrabajadas,doublevalorHora)throws EmpleadoRepetidoException {if(buscarEmpleado(codigo)==-1){ Empleado miE=newEmpleado(codigo,nombre,horasTrabajadas,valorHora);misEmpleados[posicion]=miE;verificarInvariante( );returntrue;}elsethrownew EmpleadoRepetidoException("El empleado yaexiste");}
En el caso anterior se creó un nuevo tipo de ex cepcióndenominadoEmpleadoRepetidoEx ception. Ello se logró definiendo una subclasedel tipo Ex ception.
publicclass EmpleadoRepetidoException extendsException{ public EmpleadoRepetidoException(Stringmensaje) {
super (mensaje); }}
El proceso que se sigue para crear este tipo de clases consiste en crear unanueva clase que ex tienda de Ex ception. En su interior se pone solamente unmétodo constructor, que recibe como único parámetro el mensaje de error que sedesea mostrar. En este caso, la instrucción super hace referencia al constructor dela clase base, es decir, al constructor de Ex ception.
Es muy común que en los programas se definan ex cepciones propias que heredende la clase Ex ception, pues gracias a ello es posible representar situacionesparticulares para cada problema.3.8 Diseño por contr ato
El Diseño por contrato es una metodología que se popularizó por el lenguaje deprogramación Eiffel y sefundamenta en la idea de que cada elemento de diseño esun 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 unacuerdo o contrato, en el que se ex presan los deberes y derechos de cada uno delos participantes. Esto permite que si ocurre algún problemacon remitirse alcontrato sea posibledeterminar quién era el responsable de ejecutar la tarea quefalló.
Para complementar lo anterior, es importante recordar que para asignarresponsabilidades es posible apoyarse en la técnica del ex perto o en la técnicade descomposición por requerimientos. La primera de ellas se basa en la idea deque el dueño de la información es el responsable de ella y la segunda, en que parasatisfacer un requisito funcional una forma apropiada es descomponerlo ensubproblemas para poder solucionar al requisito completo.
El Diseño por Contrato hace posible diseñar componentespartiendo del hecho quese efectuaránunas determinadas condiciones de entrada y que se garantizará elcumplimiento de ciertas condiciones de salida. De igual forma,considera que debehaber propiedades que no varíen sin importar el procesamiento que se realicedentro de un componente.
Partiendo de lo anterior, se puede afirmar que un contrato incluye tres tipos derestricciones: invariante, precondición y postcondición.- Una invariante es una condición booleana cuyo resultado siempre debe ser truepara 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 serealice una determinada operación. - Una postcondición es un predicado que, luego de haber ejecutado una determinaroperació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 laclara definición de las especificaciones. Una forma sencilla de documentar el codigo fuente a medida que se programa.
a. El contr ato de un métodoEl contrato de un método incluye la especificación de las precondiciones y laspostcondiciones. Por ejemplo, si se considera el siguiente método:publicboolean agregarEmpleado(int posicion, Stringcodigo, String nombre, int horasTrabajadas,doublevalorHora)
Se puede decir que las condiciones previas, o precondiciones, que debencumplirse para que este método se ejecute son:
El array de empleados ya se declaró y se le reservó memoria El código no esnull, 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 unnúmero positivo No se sabe si hay un empleado con este código
La precondición ex presa las restricciones necesarias para que la operaciónfuncione 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 delmétodo, mientras que la postcondición son los compromisos aceptados.b.Documentación de los contr atos
Para documentar los contratos es necesario apoyarse en Javadoc. Javadoc esuna herramienta que permite generar un conjunto de páginas web a partir de losarchivos de código que contengan los delimitadores /**… */.Javadoc permiteque laarquitectura de la solución sea mucho más comprensible.
Para lograr una adecuada documentación del contrato se debenagregarcomentarios a cada uno de los métodos que componen el programa.Un comentario permite agregar información suficiente para que otras personaspuedan 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 necesidadpara poder entender el programa a medida que crece y poder identificar posiblesfuentes de error. Una correcta documentación facilita que un software pueda ser modificado afuturo, ya sea por su creador o por cualquier otro programador que lo reemplace.
Cuando se documenta se debe ex plicar lo que no es evidente. Es decir, se debeex plicar por qué se hacen las cosas, en lugar de repetir lo que se hace. Cuando seempiece la construcción del software es importante ex plicar: 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 A cada atributo Al inicio de cada método
La escritura de un comentario Javadoc ex igen seguir una sintax is. Deben iniciarpor "/**" y terminar por "*/":
/*** Descripción clara, breve y contundente de lo quehace. * * @etiqueta texto para la etiqueta*/
Una descripción de las posibles etiquetas a utilizar para documentar una clase semuestra a continuación:
@author Nombre del autor @version Información sobre la versión y fecha @seeReferencia con otras clases y métodos
En la documentación de los constructores y métodos se deben utilizar al menoslas etiquetas siguientes:
@param@return@exception ó @throws
La siguiente tabla ilustra las posibles etiquetas que pueden utilizarse paradocumentar 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álidosDescripción de lo que se debe devolver
Excepciones que pueden surgir durante la ejecución
A continuación se muestra un ejemplo de uso de algunas etiquetas Javadoc paradocumentar 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*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
packageuniquindio.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 sedesea agregar. posicion>=0&& *posicion<MAXIMO_EMPLEADOS* @param codigo El código del empleado. codigo!=null&& !codigo.equals(" ") * @param nombre El nombre delempleado. nombre!=null && !nombre.equals(" ") * @paramhorasTrabajadas Es la cantidad de horas que trabaja elempleado. * horasTrabajadas>0* @param valorHora Es el valor que se le paga alempleado por cada hora * trabajada. valorHora>0* @throws Exception Si existe un empleado con el mismocodigo se lanza una * excepción indicando que no sepudo agregar */
publicboolean agregarEmpleado(int posicion, Stringcodigo, String nombre, int horasTrabajadas,doublevalorHora)throws EmpleadoRepetidoException {if(buscarEmpleado(codigo)==-1){ Empleado miE=new Empleado(codigo,nombre,horasTrabajadas,valorHora);misEmpleados[posicion]=miE;returntrue;}elsethrownew EmpleadoRepetidoException("El empleado yaexiste");}
Luego de finalizar la documentación se puede generar el archivo html con ladocumentación. Los pasos para ello son:
Es de anotar, que los modificadores utilizados y el tipo devuelto no forman parte dela signatura del método.También, es importante recalcarque no puede haber dosmé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 entradasy salidas del requisito funcional que el método pretende resolver, además, del tipode dato de cada uno de los parámetros requeridos. Por ejemplo, si se tiene elmétodo:
publicboolean agregarEmpleado(int posicion, Stringcodigo, String nombre, int horasTrabajadas,doublevalorHora)throws EmpleadoRepetidoException
Para poder cumplir con la responsabilidad de agregar un empleado el métodoagregarEmpleado de la clase Empresa debe recibir la posición donde deseaagregar el empleado y los datos referentes a éste.
d. La invar iante de la c lase
El Diseño por Contrato requiere también la incorporación del concepto deinvariante. Una invariante es una condición booleana cuyo resultado siempre debeser true para todas las instancias de la clase. La invariante permite verificar laconsistencia de los atributos de la clase La invariante debe usarse al final delconstructor 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 sedebe dar en todo momento en un programa para que no se produzcan errores Haydos 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. A continuación se incluyen los métodos verificarInvariante para la cada una de lasclases del caso de estudio de la Empresa.
verificarInvariante para la clase Empleado// ----------------------------------------------------------------// Invariante// ----------------------------------------------------------------/*** Verifica que el invariante de la clase se cumpla. Sialgo falla, lanza un error * <br>* <b>inv: </b><br>* misEmpleados !=null<br>* los códigos de los empleados son únicos <br>*/
publicvoid verificarInvariante( ){assert (misEmpleados!=null) : "El arreglo no puede sernull"; assert (verificarConsistencia()==true):"Haycódigos repetidos"; }
verificarInvariante para la clase Empresa// ----------------------------------------------------------------// Invariante// ----------------------------------------------------------------
/*** Verifica que el invariante de la clase se cumpla. Sialgo falla, lanza un * error <br>* <b>inv: </b><br>
* misEmpleados !=null<br>* los códigos de los empleados son únicos <br>*/
publicvoid verificarInvariante( ){assert (misEmpleados!=null) : "El arreglo no puede sernull"; assert (verificarConsistencia()==true):"Hayc�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().equago())){contador++;}}if(contador!=1){returnfalse; }}return centinela;}
Los assert en Eclipse no están habilitados por defecto. Para habilitarlos esnecesario 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 ex ista disponibilidad de acuerdoa las preferencias del cliente y se le informa el valor a pagarLiberar una sillaSe requiere cancelar una reservación ingresando para ello la cédula del clienteque la realizócedulaSi efectivamente el cliente tenía reservada una silla, ésta reservación se cancela.
4.2 Compr ensión del mundo del pr oblemaEl 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 semuestra a continuación:
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 eldía de hoy
GregorianCalendar gc = new GregorianCalendar( );
// Se obtienen los valores de dia, mes y año delcalendario 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 usuarioingresa, además de la hora y de los minutos.
public Fecha(int dia, int mes, int anio, int hora, intminuto) { 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 diferenciaen minutos entre dos fechas. Recibe como parámetro una fecha.
public Fecha calcularDiferenciaEnMinutos(FechamiFechaMayor) {GregorianCalendarmenor=devolverGregorianCalendar(this);GregorianCalendarmayor=devolverGregorianCalendar(miFechaMayor); longdiferencia = 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 loconvierte a Calendario Gregoriano
public GregorianCalendardevolverGregorianCalendar(Fecha miFecha){GregorianCalendar gcMenor = new GregorianCalendar( );gcMenor.set(miFecha.getAnio(), miFecha.getMes()-1,miFecha.getDia(), miFecha.getHora(),miFecha.getMinuto());return gcMenor;}
A continuació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 locontrario 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 PersonaACTIVIDADComplete la declaración de la clase Persona. Debe incluir los atributos, elconstructor 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 deGENERAL O PREFERENCIAL*/privateint tipo;/*** Es el estado del puesto. El estado del puesto puedeser 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 todolo referente a las reservaciones que se hagan sobre un puesto específico.
Se declaran 4 constantes, las dos primeras permiten representar los posibles tiposde puestos (GENERAL y PREFERENCIAL) y las dos últimas permiten representarlos 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 deReservaciones.
public Puesto(){misReservaciones=new Reservacion[200]; }
- El método agregarReservacion tiene varios parámetros: String cedula, intedad,int dia, int mes, int anio, int hora, int minuto yint tipo. Este método es elencargado de crear una nueva reservación, siempre y cuando no se ex ceda elmáx imo de reservaciones por puesto, es decir, 200. Cada vez que se genera unareservación el estado del puesto se pone en ocupado.
public boolean agregarReservacion(String cedula,intedad,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 dePuestos. Algunos de los métodos de esta clase son:
- El método constructor de la clase Cine. Aquí se le reserva memoria al arreglo depuestos y también a cada puesto.
public Cine (){//Se le reserva memoria al arreglo misPuestos=newPuesto[MAXIMO];
//Se le reserva memoria a cada uno de los puestos quehay 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 depuesto, para ello se apoya en la preferencia que el cliente desea. Cuandoencuentra un puesto libre acorde a la preferencia solicitada le agrega unareservación.
publicint ubicarPersona(String cedula, int edad, inttipo, int dia, int mes, int anio, int hora, intminuto){int inicio=0, finaliza=14;
//Se verifica que la persona no esté ya sentada en elcine 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 lerealizó la reservación, en caso de que ex ista 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].getMiPersonmisPuestos[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 ellosverifica 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 lasilla en libre. Finalmente devuelve la posición donde estaba ubicada la persona yel valor que debe pagar.
public ResultadoLiberacion liberarEspacio(Stringcedula){ 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);returnnewResultadoLiberacion(misPuestos[i].getMisReservaciones([misPuestos[i].getContadorReservaciones()-1].calcularValorAPagar(), i);}
}returnnull;}}
Hoja de tr abajo 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 depréstamos. Cada una de estas listas tiene una cantidad máx ima de 100.
La aplicación debe permitir:Agregar un nuevo cliente, para lo cual se solicita su nombre y códigoAgregar un nuevo autor, para lo cual se ingresa el código y nombre del autorAgregar un nuevo libro ingresando código, nombre, cantidad de ex istencias,género y listado de autores, los cuales deben previamente ex istir en el sistema.Realizar un nuevo préstamo. Informar cuál ha sido el libro más prestadoInformar que libros ha escrito un determinado autorListar los libros prestados por un determinado usuarioListar los autores de un libro
Requisito funcional 4 SalidaNombreDescripción
EntradaRequisito funcional 5
Requisito funcional 6 SalidaNombreDescripción EntradaSalidaNombreDescripción
Entrada
Requisito funcional 7 SalidaNombreDescripción Entrada
Requisito funcional 8 SalidaNombreDescripción EntradaSalidaAgregar un nuevo clienteSe debe agregar un nuevo cliente proporcionando para ello su información básica.No se podrán agregar clientes que ex istan ya en el sistema.1)nombre y 2)códigoUn nuevo cliente ha sido agregado.Agregar un nuevo autorSe debe agregar un nuevo autor proporcionando para ello su información básica.No se podrán agregar autores que ex istan ya en el sistema.
1)nombre y 2)códigoUn nuevo autor ha sido agregado.Agregar un nuevo libroSe debe agregar un nuevo libro. No se podrán agregar libros que ex istan ya en elsistema.1) codigo,2)nombre, 3)cantidad de ex istencias, 4)género y 5)listado de autoresUn nuevo libro ha sido agregadoRealizar un nuevo préstamoSe debe permitir agregar un nuevo préstamo. Es importante estar verificando que sihaya libros disponibles para prestar y que ha ese cliente no se le hay prestado eselibro ya.1) La posición en la cual está ubicado el libro dentro del arreglo de libros, 2) Laposición donde está ubicado el cliente que desea hacer el préstamo dentro delarreglo de clientesUn nuevo préstamo ha sido creadoInformar cuál ha sido el libro más prestadoSe debe devolver el libro que ha sido más prestadoNingunaEl libro más prestadoInformar que libros ha escrito un determinado autorSe selecciona el autor de un listado y se envía la posición donde estaba ubicadopara poder buscar los libros que éste ha escrito La posición donde está ubicado elautor dentro del arreglo de autores.El listado de librosListar los libros prestados por un determinado usuarioSe deben listar los libros prestados por un determinado usuario La posición dondeestá ubicado el usuario dentro del arreglo de usuariosEl listado de libros prestadosListar los autores de un libroSe debe permitir listar los autores de un libro
1)posición donde está ubicado el libro dentro del arreglo de libros El listado deautores del libro
5.2 Compr ensión del mundo del pr oblemaSe pueden identificar diferentes entidades: Biblioteca, Cliente, Autor, Libro yPréstamo:
}public String toString()
{return "cedula "+cedula+ " nombre "+nombre;}}
El método toString devuelve la representación en String del objeto, en el caso delAutor 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;
}public String toString()
{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 decopias que hay por libro. */
privateint cantidadDeExistencias;/*** El género es un entero 0--> Programación, 1-->Basesde 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;
//----------------------------------------------------------------//Constantes//----------------------------------------------------------------
/*** Es la cantidad máxima de autores*/publicstaticfinalintMAXIMO_AUTORES=5;
El constructor de la clase Libro permite inicializar los atributos de la clase, por ellorecibe el código del libro, el nombre, la cantidad de ex istencias y el género. Eneste mismo método se le reserva memoria al arreglo de autores.
public Libro(String codigo, String nombre, intcantidadDeExistencias, 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 deasignar el autor al libro se debe verificar que no se ex ceda la cantidad de autoresmáx ima, 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 realizarla solicitud. En esta clase solo es necesario construir el método constructor, quelleva dos parámetros, y los respectivos métodos get para cada uno de los atributosde 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 declaradolos 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;
//----------------------------------------------------------------//Constantes//----------------------------------------------------------------publicstaticfinalintMAXIMO=100;}
ACTIVIDADA continuación se muestran algunos de los métodos más relevantes de la claseBiblioteca. Rellene los métodos que así lo requieran.El método buscarCliente recibe el código del cliente y recorre el arreglo de clientesen 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 serecibe un codigo * y un nombre. Es de anotar que antesde agregar se verifica que el * cliente no exista enel sistema, porque no pueden haber clientes con * elmismo codigo, para ello se hace uso del métodobuscarCliente. En * caso de que buscarCliente retornenull es porque el cliente no existe, * de lo contrariose 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 agreguesatisfactoriamente
*/publicboolean agregarCliente(String codigo, Stringnombre){
if(buscarCliente(codigo)==null&&contadorClientes<MAXIMO) {}returnfalse;
El método asignarAutorLibro recibe la posición del autor dentro del arreglo deautores, 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 autoresdel libro
*/public String[] listarAutoresLibro(int posicion){
String salida[]=new String[5]; LibromiLibro=misLibros[posicion];for(int i=0; i< miLibro.getContadorAutores();i++) {} return salida; }
/*** Permite listar los libros que un usuario tieneprestados * @param posicion La posicion del usuariodentro del array de usuarios * @return un array destring con el listado de los libros */
public String[] listarLibrosPrestadosPorUsuario(intposicion) { Cliente miCliente=misClientes[posicion]; Stringprestados[]=new String[100]; int contador=0;for(int i=0; i<contadorPrestamos; i++) {
}return prestados; }
devolverCantidadEx istenciasPrestadasPorLibro permite devolver la cantidad deex istencias prestadas que hay de un libro. Con un for se recorre el array depréstamos y se busca el libro si lo encuentra se debe contar. Al final se devuelveel contador.
publicintdevolverCantidadExistenciasPrestadasPorLibro(Stringcodigo) {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 parapoder realizar el préstamo.
/*** Permite prestar una libro* @param posicionL La posicion del libro dentro delarreglo de libros * @param posicionCliente La posiciondel cliente dentro del array de * clientes* @return true si se pudo prestar el libro*/
publicboolean prestarLibro(int posicionL, intposicionCliente ) {/*
* Se debe obtener el libro y el cliente, al igual quela cantidad de * existenciasprestadas por ese libro.Es importante tener en cuenta que * si solo hay porejemplo 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 hayasido efectuado ya, * eso quieredecir que si el clientecon codigo 123 prestó el libro 45, * entonces estecliente no podrá volver a prestar ese libro */
Libro miLibro=misLibros[posicionL];Cliente miCliente=misClientes[posicionCliente];
intcantidadPrestamos=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 libromas prestado */
6.1 Requisitos funcionalesPara resolver este caso de estudio se identificaron los siguientes requisitosfuncionales:Requisito funcional 1 NombreDescripción
Requisito funcional 2 EntradaSalidaNombreDescripción
Entrada
Requisito funcional 3 SalidaNombreDescripción Entrada
Requisito funcional 4Requisito funcional 5
Requisito funcional 6 SalidaNombreDescripción EntradaSalidaNombreDescripción EntradaSalidaNombreDescripción EntradaSalidaAgregar un docenteSe debe permitir agregar un docente al listado general de docentes. Es importante
verificar que el docente no ex ista en el sistema. 1)código, 2)nombreUn nuevo docente ha sido agregadoAgregar un grupoSe debe permitir agregar un grupo al listado general. Es importante verificar que elgrupo no ex ista ya en el sistema.1) numero,2) nombre del Grupo,3) código del líder del grupo,4)el listado deintegrantes del grupoUn nuevo grupo ha sido agregadoAsignar un producto a un grupoSe debe permitir asignar un producto a un grupo1)La posición del grupo dentro del arreglo de grupos, 2) el tipo de producto ,3) Elcódigo del grupo, 4) el listado de docentes que crearon el productoUn nuevo producto se le asigna al grupoListar todos los gruposSe debe generar un listado con la totalidad de gruposNingunaEl listado de gruposListar productos de un grupoSe debe permitir el listado de productos de un determinado grupo 1) La posicióndel grupo dentro del arreglo de gruposEl listado de productos del grupo indicadoListar todos los docentesSe debe permitir listar todos los docentes que hay en la universidad NingunaEl listado de docentes
6.2 Compr ensión del mundo del pr oblemaSe pueden identificar diferentes entidades: Universidad, GrupoDeInvestigacion,Docente y Producto.
También es necesario un método constructor, los correspondientes métodos getpara cada uno de los atributosy el método toString.
public String 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 ellistado de docentes que crearon el producto. Antes de agregar el producto se debeverificar que no se ex ceda el máx imo 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 algrupo. Es importante verificar que dicho docente ya no ex iste en el grupo, con elobjetivo de evitar repeticiones.
publicvoid agregarIntegranteGrupo(DocentemiIntegrante) {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 verificasi en esa posición //hay producto, en tal caso seagrega al arreglo productos la //representación enString de dicho productoString 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) olibro (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,DocentemisDocentes[]) {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 claseUniversidad. Sus atributos se muestran a continuación:
publicclass Universidad {//----------------------------------------------------------------// Atributos//----------------------------------------------------------------/**
* Es el listado de grupos de investigacion
*/private GrupoDeInvestigacionmisGruposDeInvestigacion[]; /*** Es el listado general de docentes*/private Docente misDocentesGeneral[];
//----------------------------------------------------------------//Constantes//----------------------------------------------------------------/**
* Es la constante para manejar el número máximo dedocentes y grupos */privatestaticfinalintMAXIMO=100;}
Se destacan los siguientes métodos:El método agregar docente se encarga de insertar un nuevo docente en el arreglode 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. Deberecorrer el arreglo de grupos en su búsqueda. En caso de encontrarlo devuelve laposició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 grupode investigación, a saber: el número del grupo, el nombre, el código del líder y unarreglo con las posiciones dentro del array de docentes de las personas que van aincorporarse.
publicint agregarGrupo(int numero,StringnombreGrupo,String codigoLid,int integrantes[]){int posicionEnArregloDelGrupo=0;intposicionLiderEnArregloGeneral=GrupoDeInvestigacion.busmisDocentesGeneral);Docente misDocentesDelGrupo[]=newDocente[integrantes.length];for(int i=0; i<misDocentesDelGrupo.length; i++){misDocentesDelGrupo[i]=misDocentesGeneral[integrantes[if(misDocentesDelGrupo[i].getCodigo().equals(misDocenteregloGeneral].getCodigo())){
posicionEnArregloDelGrupo=i;}}
GrupoDeInvestigacion miGrupo= newGrupoDeInvestigacion();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 cualse le asignará, ya sea el libro o el artículo, además del listado de integrantes queelaboró el producto.
publicvoid agregarProductoAGrupo(int posGrupo, inttipo, String codigo, int integrantes[]){Docente misDocentesDelGrupo[]=newDocente[integrantes.length]; for(int i=0;i<misDocentesDelGrupo.length; i++)
{misDocentesDelGrupo[i]=misDocentesGeneral[integrantes[}Producto miProducto=new Producto(tipo, codigo,misDocentesDelGrupo);misGruposDeInvestigacion[posGrupo].agregarProducto(tipocodigo, misDocentesDelGrupo);}
ESTRUCTURAS CONTENEDORAS DE TAMAÑO VARIABLE1 ObjetivosAl finalizar la unidad el estudiante estará en capacidad de: Utilizar estructuras contenedoras de tamaño variable para resolver problemas enlos cuales es necesario almacenar una secuencia de elementos cuya cantidad nose conoce con anterioridad. Utilizar ciclos para poder manipular las estructuras contenedoras variables2 Motivación
Algunas veces se requiere resolver problemas en los cuales es necesarioalmacenar una secuencia de elementos, pero no se sabe cuántos. Estacaracterí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óny unión entre varios conjuntos. Se debe permitir también que se eliminen todos losconjuntos que se han agregado hasta el momento. El resultado de las operacionesde unión e intersección se deben mostrar ordenados alfabéticamente.
Requisito funcional 4 EntradaSalidaNombreDescripción
EntradaSalidaNombreDescripción
Entrada SalidaHallar la intersección entre varios conjuntosSe debe hallar la intersección entre todos los conjuntos que el usuario hayaingresado hasta el momento. La intersección consiste en encontrar los elementosque son comunes en todos los conjuntos.NingunaUn nuevo conjunto con el resultado de la intersecciónHallar la unión entre varios conjuntosSe debe hallar la unión entre todos los conjuntos que el usuario haya ingresadohasta el momento.NingunaUn nuevo conjunto con el resultado de la uniónOrdenar alfabéticamente los elementos de un conjuntoSe recibe un conjunto y se aplica un método de ordenamiento para lograr que loselementos queden ubicados de menor a mayor Un conjuntoEl conjunto ordenadoEliminar los conjuntosSe debe permitir borrar todos los conjuntos que se han ingresado hasta elmomentoNingunaLos conjuntos han sido eliminados
3.2 Compr ensión del mundo del pr oblemaSe pueden identificar diferentes entidades: GrupoConjunto y Conjunto.
3.3 Diseño y constr ucción de la solución del pr oblema
Este caso de estudio requiere de la utilización de estructuras contenedoras detamaño variable, en la cuales no se requiere que se conozca su tamaño máx imotal como ocurre en los arreglos, pues crece o disminuye dinámicamente.
En Java ex isten varias clases que permiten crear este tipo de estructuras, entreellas la clase Vector o la clase ArrayList. En este documento se hará uso de lasegunda.Cuando se debe representar en el diagrama de clases este tipo de asociacionesse coloca como cardinalidad los símbolos 0…* para aclarar que su tamaño puedevariar.Todo ArrayList debe declararse y se le debe reservar memoria. Tal como semuestra a continuación:private ArrayList <Conjunto> misConjuntos ;public GrupoConjunto()
{misConjuntos=new ArrayList<Conjunto>();}
En la clase GrupoConjunto se declara un Vector donde cada elemento correspondea un conjunto. Para que esto sea posible es necesario importar el paquetejava.util.*;
Observe que al momento de reservarle memoria no fue necesario indicar lacantidad de elementos que iba a contener. Esto quiere decir, que automáticamentese arranca con 0 elementos dentro de él. No obstante, ArrayList también brinda laposibilidad 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 estructuraisEmpty(): Devuelve true si no hay elementos en el ArrayList, de lo contrariodevuelve false.add(elemento): permite agregar al final de la estructura contenedora un nuevoelemento.
add(posición, elemento): permite agregar un elemento en la posición indicada. Siya había un elemento en esa posición, el elemento que ya ex iste y todos los quese 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 laposición por un nuevo elemento.
remove (posición): borra el elemento que está en la posición indicada, esto implicaque los elementos que estaban a la derecha del elemento eliminado se correránhacia la izquierda para ocupar el lugar eliminado. Esta operación hace que eltamaño de la estructura se reduzca en 1. remove(elemento): en este caso se envíael objeto que se desea eliminar. Es importante aclarar, que si se crea un nuevoelemento con los datos del objeto que se desea eliminar no indica que sea elmismo elemento. Para que sean iguales deben ocupar la misma posición dememoria, es decir, deben ser la mismas instancia.
contains(elemento): Devuelve true si el elemento ex ist, de lo contrario devuelvefalse.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 lasclases 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 tieneparámetros. Su objetivo es reservarle memoria al ArrayList de elementos delconjunto.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 memoriaal Arraylist, surgiendo entonces un conjunto con cero elementos. En el segundoconstructorse 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 delconjunto.
public String toString()
{return misElementos.toString(); }
Por otra parte, en la clase GrupoConjuntos se encuentran, entre otros, lossiguientes 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 unArrayList de un ArrayList de String, esto quiere decir, que se tendrá un ArrayListgeneral llamado arreglo, que en la posición cero almacenará otro ArrayList deString (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 encargade convertir los elementos que hay en la posición cero del arrayList que recibe enun nuevo conjunto, los elementos que hay en la posición 1 en un nuevo conjunto yasí continúa hasta que recorra todo el ArrayList. Este objetivo se logra a través delas 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 eltécnica de ordenamiento de Burbuja para ordenar ascendentemente los elementosdel conjunto.
public Conjunto ordenarAlfabeticamente(ConjuntomiConjunto) {//Se aplica burbuja para ordenarArrayList<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 cuyoselementos son: 66 39 4 35 y 2 y que se ordenará siguiendo la estrategia mostradaen la siguiente tabla.66 39 4 35 239 66 4 35 239 4 66 35 239 4 35 66 239 4 35 2 664 39 35 2 664 35 39 2 664 35 2 39 664 35 2 39 664 2 35 39 664 2 35 39 664 2 35 39 662 4 35 39 662 4 35 39 662 4 35 39 66
2 4 35 39 66 Se puede observar que lo que se ha hecho es desplazar loselementos más pequeños hacia el inicio del arreglo (hacia el primer elemento) ylos elementos mayores se movieron hacia el fondo del arreglo. Generalizando, loque se hizo es tomar el elemento mayor, el cual se fue recorriendo de posición enposición hasta ponerlo en su lugar. A este método de ordenamiento se le conocecomo Burbuja.
Es importante anotar, que ex isten otros métodos de ordenamiento, entre ellos sedestacan 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 unarreglo 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. Luegosigue con el tercero y lo coloca en su posición ordenada con respecto a los dosanteriores, así sucesivamente hasta recorrer todas las posiciones del arreglo.
Otro método muy conocido es el de Selección, el cual consiste en encontrar elmenor de todos los elementos del arreglo e intercambiarlo con el que está en laprimera posición. Luego el segundo más pequeño, y así sucesivamente hastaordenar todo el arreglo.
Por otra parte, el método public ConjuntohallarUnion(), crea un ArrayList de Stringen el cual se incluyen todos los elementos de todos los conjuntos verificando queno se presenten repeticiones.
public Conjunto hallarUnion(){ ArrayList<String> resultado=new ArrayList<String>();
for (int i=0; i<misConjuntos.size(); i++){for(intj=0;j<misConjuntos.get(i).getMisElementos().size();j++
{
Stringdato=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 recorrecada uno de los elementos del conjunto cero. A través del segundo for se obtienentodos los conjuntos (diferentes al conjunto cero) y con el tercer for, se recorren loselementos de cada uno de esos conjuntos. La idea general consiste en que cadaelemento obtenido del conjunto cero debe compararse con cada uno de loselementos que hay en cada conjunto. Si al final se determina que un elemento delconjunto cero, está presente en todos los demás conjuntos, ese elemento seselecciona 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 obtienecada uno de sus elementos es decir, se obtiene elelemento 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 delos elementos que hay en cada conjunto. Por lo tanto se toma cada uno de losconjuntos que son diferentes al conjunto 0 y se saca cada uno de los elementos paraluego 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 comparadodebe estar repetido 3 //vecesif(contador==misConjuntos.size()-1){ Stringelem=misConjuntos.get(0).getMisElementos().get(j);if(!misElementos.contains(elem))misElementos.add(elem);} }returnnew Conjunto(misElementos);}}
4 Caso de estudio N.2 Conjunto Cer r ado (CódigoFuente:unidadIICaso02ConjuntoCer r ado)
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 pagar142000 por concepto de administración (pues son casas de dos plantas), lasrestantes deben pagar este mismo valor incrementado en un 10% ( son casas detres plantas). Cada casa tiene un listado de habitantes, un número y una cantidadde 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 13años la administración solicita al propietario de la vivienda que informe si el menorpuede salir o no del conjunto.
La aplicación debe permitir adicionalmente mostrar el listado de propietarios deviviendas y la cantidad de niños autorizados a salir del conjunto, también el totalrecaudado en administración.
NombreDescripción
Entrada SalidaRegistrar una persona en una determinada casaSe debe registrar una persona, para ello se ingresan sus datos personales y seindica si es o no el propietario. Si la persona es menor de 13 años el propietariodebe 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)edadLa persona ha sido registradaListar todos los propietarios del conjuntoSe debe recorrer el listado de casas y por cada una de ellas sacar el propietario.NingunaLa lista de propietariosCalcular el total recaudado en administraciónPara calcular el total recaudado en administración se debe tener en cuenta que lasprimeras 35 deben pagar 142000 por concepto de administración, las restantesdeben pagar este mismo valor incrementado en un 10% . Si la casa no tienepropietario, es decir, aún pertenece a la constructora no debe pagar administración.NingunaEl total recaudado por concepto de administración
4.2 Compr ensión del mundo del pr oblemaLas clases identificadas son: ConjuntoCerrado, Casa, Habitante
//----------------------------------------------------------------//Constantes//----------------------------------------------------------------/*** 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 seindica 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. A través de ellos es posiblecrear el nuevo habitante que luego será agregado al ArrayList de habitantes.
publicvoid agregarHabitante(String nombre, Stringidentificacion, boolean autorizacionSalir, booleanpropietario,int edad){
misHabitantes.add( new Habitante(nombre,identificacion, autorizacionSalir, propietario,edad));}
El método calcularValorAPagarAdministracion verifica el número de la casa, si esmenor de 35, entonces informa que debe pagar 142000, de lo contrario le aumentaun 10% a este valor. No se le cobra administración a viviendas que no tienenpropietario, 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 lossiguientes: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 porcada casa el ArrayList de habitantes y verifica si el habitante es menor de 13 añosy 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 elvalor 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 usuariode 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 entre4 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 yVentana y las posibles clases son Económica y Ejecutiva. La clase ejecutivacorresponde a los puestos ubicados en la diagonal principal y secundaria en lasprimeras 4 filas. En el avión siempre habrá una zona inactiva que corresponde alos elementos que se encuentran entre la diagonal principal y secundaria en lascuatro primeras filas.Todos los demás puestos corresponden a ubicacióneconómica.
Es muy importante que se conserve el registro de todos los pasajeros que se hansentado en cada una de las sillas.También se debe permitir eliminar un pasajero indicando su cédula y consultar lainformación de un pasajero indicando su posición.
SalidaNombreDescripción
Entrada SalidaUbicar un pasajero El pasajero llega a la aeropuerto y da sus datos personales y preferencias en tornoa clase y ubicación1)cedula, 2)nombre, 3)clase, 4)ubicaciónEl pasajero ha sido ubicadoCancelar la reservación de un pasajeroPara cancelar la reservación de un pasajero se debe solicitar la cédulaLa cédulaLa reservación ha sido canceladaConsultar la información de un pasajeroPara consultar la información de un pasajero se debe informar la posición en lacual está ubicadoLa posiciónEl pasajero que está ubicada en dicha posición
5.2 Compr ensión del mundo del pr oblemaSe pueden identificar diferentes entidades: Avión, Puesto y Persona
/*** Es la cedula de la persona*/private String cedula;}
En esta c lase se r equier e de un constr uctor y los cor r espondientesmé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 yreservarle 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. Conestos datos se crea la persona que se va a agregar al ArrayList. Luego de agregaruna persona la variable estado se pone en 1.
publicvoid agregarPersona(String nombre, Stringcedula) { Persona miPersona = newPersona(nombre,cedula); misPersonas.add(miPersona);estado=1;
}
- Para eliminar una persona sólo se pone el estado en cero. No se eliminafí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 acada uno de los Puestos. Es importante ir colocando la clase y la ubicación acada puesto a mediad que se van creando.
Observe que la clase se le asignó a cada puesto a través de una enumeración. Talcomo se muestra a continuación:
/*Aqui se crean todas las sillas que están enmantenimiento*/ 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 yse capturan todas las posiciones para poder crear lassillas inactivas*/for(int i=0; i<4;i++){
inicio.add(i*izq);finaliza.add(derecha*(i+1));misPuestos.get(i*izq).setClase(Clase.EJECUTIVA.getNumCmisPuestos.get(derecha*(i+1)).setClase(Clase.EJECUTIVA.getNumClase()); }/*Aqui se crean todas las sillas que están enmantenimiento*/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, puespor defecto se inicializaron con tipo 0 que eseconómica. Ahora se fijan las ventanas. No esnecesario fijar el centro pues por defecto seinicializó con cero. */for(int i=0; i<=filas*columnas-columnas; i+=columnas ){misPuestos.get(i).setUbicacion(Ubicacion.VENTANA.getNummisPuestos.get(i+columnas-1).setUbicacion(Ubicacion.VENTANA.getNumUbicacion());
}}
El método ubicarPasajero se encarga de ubicar un pasajero en un puesto acorde alas preferencias ex presadas con respecto a la clase y la ubicación. Si el pasajeroya ex iste, 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 elenum. Un enum se utiliza para limitar el contenido de una variable a una lista devalores definidos con anterioridad. Un tipo enumerado es una instancia del tipoenumerado del cual se declaró. No se puede considerar como un String o unentero.
publicenum Clase {//Clases de puestosEJECUTIVA (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 puestosque 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, sitoma 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 lospuestos que hay en el Cine. Es importante mostrar como mínimo el número depuesto, el estado del puesto y la clase del puesto.Para este caso de estudio también se creó una enumeración para trabajar laUbicació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 for each en Java
En el método buscar pasajero se utilizó la estructura repetitiva for-each, la cualpermite iterar sobre colecciones de objetos.Toda Collection tiene un tamaño ypuede recorrerse para conocer cada uno de los elementos que almacena. En Javahay 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 posibleir obteniendo uno a uno los objetos al ir llamando repetitivamente método nex t(). 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 unacollección, que es sumamente útil en el caso de que no se requiera eliminarelementos. Esta estructura es el foreach. Tiene la siguiente sintáx is:
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 elArrayListfor(Puesto miPuesto: misPuestos){//Por cada puesto se verifica que haya persona y quela cedula de dicha persona //coincida con la cédula dela persona buscada if(miPuesto.getMisPersonas().size()>0&&miPuesto.getMisMisPersonas().size()-1).getCedula().equals(cedula)&&mi
{return miPuesto.getNumero();}}return -1;}
6.1 Requisitos funcionalesPara resolver este caso de estudio se identificaron los siguientes requisitosfuncionales:Requisito funcional 1 NombreDescripción
Requisito funcional 2 EntradaSalidaNombreDescripción Entrada
Requisito funcional 3
Requisito funcional 4 SalidaNombreDescripción EntradaSalidaNombreDescripción
Entrada
Salida Registrar un nuevo clienteSe debe registrar un nuevo cliente, para ellos se debe solicitar el código y elnombre. No se podrán registrar clientes que ya ex istan en el sistema.1)código, 2)nombreUn nuevo cliente ha sido registradoAgregar una nueva cuentaSe debe permitir registrar una nueva cuenta1)número de la cuenta, 2)el monto, 3)el tipo de cuenta (ahorro o corriente), 4)Laposición donde se encuentra ubicado el cliente al cual se le va a crear la cuentaSe ha creado una nueva cuenta
Generar el listado de las cuentas ordenado por montoSe debe generar el listado de cuentas ordenadas por mont NingunaEl listado de las cuentas ordenadas por montoGenerar listado de cuentas por clienteSe debe generar listado de cuentas por cliente. Se podrá discriminar también por eltipo de cuenta 0 ó 1 o todas. 1) Posición del cliente dentro del ArrayList declientes, 2) El tipo de consulta deseada ( Ahorro, corriente, todas)El listado de cuentas que tiene el cliente, de acuerdo al tipo seleccionado
6.2 Compr ensión del mundo del pr oblemaSe pueden identificar diferentes entidades, a saber: Banco, Cliente y Cuenta.
/*** Es el nombre del cliente*/private String nombre;}
En esta clase se construyó un método constructor con dos parámetros y losmétodos get para cada uno de los atributos.En la clase Cuenta se encuentran los siguientes atributos:
publicclass Cuenta {//----------------------------------------------------------------// Atributos//----------------------------------------------------------------/**
* Es el numero de la cuenta*/private String numero;/*** Es el cliente dueño de la cuenta*/private Cliente miCliente;/*** Es el tipo de la cuenta( 0-> ahorro, 1->corriente)*/privateint tipo; /*** Es la cantidad de dinero que hay en la cuenta*/privatedouble cantidadDinero;
//----------------------------------------------------
------------//Constantes//----------------------------------------------------------------/**
* Es la constante para manejar la cuenta de tipoahorro */publicstaticfinalintTIPO_AHORRO=0;/*** Es la constante para manejar la cuenta de tipocorriente*/publicstaticfinalintTIPO_CORRIENTE=0;}
Algunos de los métodos más importantes de esta clase son los mostrados acontinuación:El método constructor que permite inicializar los atributos numero, tipo ycantidadDinero.
public Cuenta(String numero, int tipo, doublecantidadDinero) { this.numero = numero;this.tipo = tipo;this.cantidadDinero = cantidadDinero;
}
El método agregarCliente permite inicializar el atributo miCliente.publicvoid agregarCliente(Cliente miCliente)
{ this.miCliente=miCliente;}
El método toString() devuelve un String con la representación en String de lacuenta. public String toString(){String cuenta="Corriente ";if(tipo==0)cuenta="Ahorro ";return "Número "+numero+ " Tipo: "+cuenta+" Dinero"+cantidadDinero; }
Finalmente, en la clase Banco se tienen entre otros los siguientes métodos.
El método agregarCuenta lo primero que hace es verificar que la cuenta que se vaa crear no ex ista. Si es así, entonces se crear una nueva cuenta y se le agrega elcliente que le usuario indicó. Antes de poder agregar esta cuenta, se debecomprobar a través de buscarCantidadCuentasTipo que el usuario no ex ceda eltope de cuentas por tipo, que es de 3.
publicboolean agregarCuenta(String numero, int tipo,double cantidadDinero, ArrayList <Integer>posClientes){if(buscarCuenta(numero)==-1)
{
Cuenta miC= new Cuenta(numero, tipo, cantidadDinero);for(int i=0; i<posClientes.size(); i++){
Cliente cliente=misClientes.get(posClientes.get(i));if(buscarCantidadCuentasTipo(tipo,cliente.getIdentificacion())<3)
{miC.agregarCliente(cliente);}
}misCuentas.add(miC);returntrue;}returnfalse;}
El método buscarCantidadCuentasTipo recibe el codigo de la persona y el tipo decuenta que se pretende crear. La idea es recorrer el ArrayList de cuentas e irpreguntado por cada cuenta si el propietario es el mismo cliente y si el tipo de lacuenta coincide con el tipo de la cuenta que se desea crear, si es así secontabiliza.
publicint buscarCantidadCuentasTipo(int tipoCuenta,String codPersona) {int contador=0;for(int i=0; i<misCuentas.size(); i++){if(misCuentas.get(i).getMiCliente().getNombre().equalsmisCuentas.get(i).getTipo()==tipoCuenta){
contador++; }}return contador; }
El método buscarCuentasClienteTipo recorre el ArrayList comparando el tipo de lacuenta con el tipo buscado y el codigo del propietario de la cuenta con el códigobuscado, si coinciden se agrega a uno de los ArrayList creados. Hay dosArrayList: en cuentasClienteTipo se agregan las cuentas si la solicitudcorresponde a corriente o ahorro, en todasCuentasCliente se agregan todas lascuentas, pues el usuario ha solicitado ver todas las cuentas, sin discriminar entrecorriente y ahorro.
public String[] buscarCuentasClienteTipo(inttipoCuenta, int posPersona) {StringcodPersona=misClientes.get(posPersona).getIdentificacioArrayList <Cuenta> cuentasClienteTipo=newArrayList<Cuenta>(); ArrayList <Cuenta>todasCuentasCliente=new ArrayList<Cuenta>();
for (int i=0; i<misCuentas.size(); i++){if(misCuentas.get(i).getMiCliente().getIdentificacion({
todasCuentasCliente.add(misCuentas.get(i));if(misCuentas.get(i).getTipo()==tipoCuenta)
{cuentasClienteTipo.add(misCuentas.get(i)); }}}
if (tipoCuenta==2)return pasarArrayListAArreglo(todasCuentasCliente);else
return pasarArrayListAArreglo(cuentasClienteTipo); }
Finalmente el método ordenarCuentas genera el listado de cuentas ordenado pormonto, utilizando el método burbuja.
public String[] ordenarCuentas(){for(int i=0; i< misCuentas.size(); i++)
{for(int j=0; j< misCuentas.size()-1; j++){if(misCuentas.get(j).getCantidadDinero()<misCuentas.get(j+1).getCantidadDinero())
{Cuenta temp=misCuentas.get(j); misCuentas.set(j,misCuentas.get(j+1)); misCuentas.set(j+1, temp);
}}}return pasarArrayListAArreglo(misCuentas);
}}
ARRAY BIDIMENSIONAL1 ObjetivosAl finalizar la unidad el estudiante estará en capacidad de: Utilizar estructuras contenedoras de tamaño fijo en dos dimensiones para resolverproblemas en los cuales es necesario almacenar una secuencia de elementos Utilizar ciclos para poder manipular las estructuras contenedoras fijas de dosdimensiones Conocer y aplicar los patrones de algoritmo para recorrido de matrices.2 Motivación
Frecuentemente se presentan muchos casos en los cuales se requiere trabajarcon estructuras contenedoras de dos dimensiones. Por ejemplo, un cine en el cualhay una serie de puestos distribuidos en filas y columnas. En este nivel seex plicará cómo se declaran y crean este tipo de estructuras contenedoras, a lascuales se les conoce como matrices.
3 Caso de estudio N.1 El c ine (Código Fuente: unidadIIICaso01Cine)
Se desea crear una Aplicación para un Cine en cual hay 180 puestos distribuidosen 12 filas y 15 columnas. Cada puesto tiene un número (formado por una letra yun número entre 0 y 14) y un estado. El puesto o no estar ocupado por unapersona. Una persona tiene una cédula. La numeración de los puestos inicia enA0… A14, continúa en B0… B14…. y así sucesivamente hasta llegar a L0…. L14.
Se requiere que se pueda ubicar una persona en el cine informando para ello sucédula, tipo de preferencia, cantidad de sillas que desea y si requiere o no queéstas sean consecutivas. El usuario podrá indicar la fila de su preferencia pararealizar su reservación.
También se necesita eliminar una reservación indicando la posición del puesto,calcular el total recaudado en categoría general y calcular el total recaudado encategoría preferencial.
columnaLa reservación ha sido eliminadaCalcular el total recaudado por tipo de preferenciaSe debe calcular el total recaudado por tipo de preferencia El tipo de preferenciaEl total recaudado
3.2 Compr ensión del mundo del pr oblema
Se pueden identificar diferentes entidades, a saber:
3.3 Diseño y constr ucción de la solución del pr oblemaPara resolver este caso de estudio se requiere la incorporación del concepto dearreglos dimensionales o matrices. Los Array Bidimensionales también seconocen como tablas o matrices.Es de anotar, que Java no soporta los arreglos multidimensionales de formadirecta. No obstante, permite trabajar con un arreglo de arreglos. La propiedad length permite obtener el tamaño del arreglo. Para obtener el númerode filas se utiliza matriz.length y para obtener el número de columnas se utilizamatriz[0] length.Toda matriz debe ser declarada y se le debe reservar memoria. La sintax isutilizada para la declaración es la siguiente:<TipoDato> nombreMatriz[][];
ó<TipoDato> [][] nombreMatriz;
Para reservarle memoria se usa el operador new. Ejemplo:nombreMatriz=new <TipoDato>[cantidadDeFilas][cantidadDeColumnas];
La declaración y reservada de memoria también se puede hacer en una sola línea. int matriz[][]=new int[4][5];Puesto misPuestos[][]= new Puesto[12][15];
Como puede verse es posible crear arraysen dos dimensiones de objetos, perohay que tener precaución pues luego de reservarle memoria al arreglo seránecesario crear cada uno de los objetos que va a almacenar.
Luego de que se reserva memoria, Java inicializa los arreglos dependiendo deltipo de dato, ejemplo si el arreglo es de enteros, se inicializa por defecto conceros, pero si es de objetos se inicializa con null.
También es posible inicializar los arreglos al momento de la declaración:int edad[][]={{3,4,5},{5,6,7}};
Cada elemento dentro del array bidimensional tiene una posición dada, la cualestá formada por una fila y una columna. Esto quiere decir que para moversedentro de este tipo de estructuras se requiere de dos índices, normalmente i y j. Elprimero de ellos se desplaza en las filas, y toma valores entre 0 y matriz length yel segundo, se mueve en las columnas y toma valores entre 0 y matriz[0].length.
La siguiente tabla está formada por 4 filas y 4 columnas. Dentro de cada celda sehan colocado, en la parte superior los respectivos índices. El primero de elloscorresponde a la fila (i) y el segundo a la columna(j). Ejemplo si se tiene laposicion 0,3 quiere decir que se está ubicado en lafila 0 y en la columna 3.Es importante tener claro que una cosa es la posición y otra lo que se encuentraalmacenado en dicha posición. Por ejemplo, en la posicion 0,3 se encuentraalmacenado un 1 En la posicion 1,3 se encuentra almacenado un 70, en laposicion 32 se encuentra almacenado un 4.
Columna
Fila 00 01 02 030 5 6 1
10 11 12 138 1 7 70
20 21 22 2310 30 0 80
30 31 32 332 7 4 8
Observe que:la i toma valores entre 0 y matriz.length-1 la j toma valores entre 0 ymatriz[0] length-1
Una importante estrategia que permite el desarrollo de la lógica sobre las matrices
consiste en poner los índices sobre cada uno de los elementos que la matrizpuede contener, pues gracias a ello es posible identificar aspectos importantesque permitan realizargeneralizaciones . Por ejemplo:
Se desea sumar todos los elementos de la diagonal: En la diagonal, la i y la j soniguales: 00, 11, 22, 33…Se desea sumar los los elementos de la primera y última columna: En este caso,j==0 || j== matriz[0].length-1
Se desea obtener los elementos de la diagonal secundaria: Observe que lasposiciones correspondientes a esta diagonal son 03, 12, 21 y 30. En este caso lasumatoria del valor en i con el valor de j siempre da 3. Es decir, (i+j)==matriz[0] length-1
El caso de estudio del Cine requiere la creación de la clase Persona, que cuentacon un solo atributo, además del correspondiente método constructor y get.
publicclass Persona {//----------------------------------------------------------------// Atributos//----------------------------------------------------------------/**
* Es la cedula de la persona*/private String cedula;}
En la clase Puesto se tienen, además de los métodos set y get de los atributosnumero, tipo, estado, los siguientes métodos:- El método constructor que permite inicializar los atributos de la clase.
public Puesto(String numero, int tipo, int estado) {
super();this.numero = numero;this.tipo = tipo;this.estado = estado;
}
- En la clase Puesto se crearon dos métodos setMiPersona, apoyándose en lasobrecarga de métodos. El primero de ellos, permite fijar la persona en null y elestado en cero, es decir cumple la función de eliminar la persona. El segundopermite inicializar la persona con la información que el usuario ingresa.
publicvoid setMiPersona() { this.miPersona = null;estado=0;
}
publicvoid setMiPersona(String cedula) {this.miPersona = new Persona(cedula); estado=1;
}
Por último, se presentan algunos de los métodos de la clase Cine.
En el constructor de Cine se le reserva memoria a la matriz y luego a cada uno delos puestos. A medida que se crea un puesto se le asigna el número, la categoría yel estado. El número se calcula apoyado en la variable char letra.
public Cine(){misPuestos=new Puesto[12][15];char letra='A';for(int i=0; i<misPuestos.length; i++) {for(int j=0; j<misPuestos[0].length; j++)
{if(i<9) misPuestos[i][j]=newPuesto(letra+""+j,Puesto.GENERAL,0); else
misPuestos[i][j]=newPuesto(letra+""+j,Puesto.PREFERENCIAL,0);
}letra++;}}
El método liberar recibe la fila y la columna donde está ubicado el puesto que sedesea liberar. Si el puesto no está ocupado se genera una ex cepción.
publicboolean liberar(int i, int j) throws Exception {if(misPuestos[i][j].getEstado()==1){
misPuestos[i][j].setMiPersona();returntrue;}elsethrownew Exception("El puesto no tiene personas y porello no se puede liberar"); }
El método obtenerDineroPorTipo, tiene como parámetro el tipo deseado y seencarga de calcular el total recaudado, para ello se apoya en el métodocontarPorTipo.
publicdouble obtenerDineroPorTipo(int tipo) {double res=0;if(tipo==0)
res=contarPorTipo(tipo)*Puesto.PRECIO_GENERAL; else
res= contarPorTipo(tipo)*Puesto. PRECIO_PREFERENCIA;return res;}
publicint contarPorTipo(int tipo) {int contador=0;for(int i=0; i<misPuestos.length; i++) {for(int j=0; j<misPuestos[0].length; j++) {
if(misPuestos[i][j].getMiPersona()!=null&&misPuestos[i][j].getTipo()==tipo){contador++;}
}}return contador; }
3.4 Patr ones par a r ecor r ido sobr e matr icesLos patrones para recorrer estructuras contenedoras de dos dimensiones son lossiguientes:a) Patr ón de r ecor r ido TotalMediante este patrón se tiene acceso a cada una de las posiciones del arreglobidimensional. Se requieren dos for, el primero de ellos maneja la fila y el segundode ellos la columna.Un ejemplo de este tipo de patrón es el siguiente:
publicint contarPorTipo(int tipo) {int contador=0;for(int i=0; i<misPuestos.length; i++) {for(int j=0; j<misPuestos[0].length; j++) {
if(misPuestos[i]
[j].getMiPersona()!=null&&misPuestos[i][j].getTipo()==tipo) {contador++;}
}}return contador; }
b) Patr ón de Recor r ido Par c ialSe recorre el arreglo bidimensional y por cada elemento se verifica si ya secumplió la condición de finalización del ciclo, es decir, si el problema ya fueresulto. Por ejemplo;
public int buscarPersona(String codigo){for(int i=0; i<misPuestos.length; i++){for(int j=0; j<misPuestos[0].length; j++){if(misPuestos[i][j].getMiPersona()!=null&&misPuestos[i][j].getMiPersona().getCedu la().equals(codigo)){return i;}
}}return -1; }
4 Caso de estudio N.2 El Bingo (Código Fuente: unidadIIICaso02Bingo)
Se requiere de una aplicación para jugar Bingo. La aplicación debe generar tantostableros aleatorios como clientes deseen jugar. Cada tablero está formado por 5filas y 5 columnas. Los números correspondientes a la columna B pueden tomarvalores entre 0 y 9, los valores válidos para la columna I son entre 10 y 19, para laN entre 20 y 29, para la G entre 30 y 39 y para la última columna entre 40 y 49.Cada tablero debe ser único.
Descripción
Entrada Generar un tableroCada vez que llega un cliente a comprar un tablero debe informar sus datospersonales para que el sistema lo genere.Se debe verificar que el tablero sea válido, es decir, que ese tablero no ex ista ya.1) teléfono, 2)nombre, 3) cedulaUn nuevo tablero ha sido generadoSacar una balota.El sistema aleatoriamente deberá seleccionar un número entre 0 y 49. NingunaUn número entre 0 y 49Actualizar todos los tableros luego de que se selecciona una balota Para cadatablero se debe verificar si la balota seleccionada por el sistema está incluidadentro de dicho tablero. En tal caso, esto se debe registrar.1)El número de la balota seleccionadaRequisito funcional 4
Requisito funcional 5 SalidaNombreDescripción EntradaSalidaNombreDescripción
Entrada SalidaLos tableros han sido actualizadosListar todos los tableros vendidosSe debe permitir mostrar los listados vendidosNingunaEl listado de tableros vendidos
Verificar si hay ganadorLuego de que se seleccione una balota el sistema debe verificar si algún tablerose ha llenado completamente. Puede ocurrir que se completen varios tablerosNingunaEl listado de tableros ganadores
3.6 Compr ensión del mundo del pr oblemaSe pueden identificar diferentes entidades, a saber Bingo, Tablero, Posición yPropietario.3.7 Diseño y constr ucción de la solución del pr oblemaPara resolver este caso de estudio se iniciará con la clase Posición. Una posiciónestá formada por un número, una letra y un estado (seleccionado o noseleccionado).
publicclass Posicion {//----------------------------------------------------------------// Atributos//----------------------------------------------------------------/*** Es el número de la posicion*/
privateint numero;/*** Seleccionado es cero si el sistema no ha sacado estenúmero sino es 1. */privateint seleccionado;/*** Es una letra de la palabra Bingo*/privatechar letra;}
Adicionalmente a los métodos get y set para cada uno de los atributos se tienen elsiguiente método:
public Posicion(int numero, int seleccionado) {this.numero = numero;this.seleccionado = seleccionado;
}
En la clase Tablero, se tiene entre otros métodos los siguientes:En el constructor de Tablero se le reserva memoria a cada una de las posicionesdel tablero, pero no se les asigna número.
public Tablero(int numero){matriz=new Posicion[Bingo.CANTIDAD_FILAS][Bingo.CANTIDAD_FILAS]; for(int i=0;i<Bingo.CANTIDAD_FILAS;i++){for(int j=0; j<Bingo.CANTIDAD_FILAS;j++){
matriz[i][j]=new Posicion(0,0);
}}this.numero=numero; }
El número luego se modifica con base en el número seleccionado aleatoriamentepor el sistema para crear el tablero, para ello se utiliza el método modificarNumero.Cuando se piensa modificar un número se debe verificar que en esa columna yano ex ista.
publicboolean modificarNumero(int colu, int fil, intnumero) {for(int i=0; i<Bingo.CANTIDAD_FILAS; i++) {if(matriz[i][colu].getNumero()==numero) {returnfalse; }
} matriz[fil][colu].setNumero(numero); returntrue;}
Luego de que el juego ha iniciado y el sistema selecciona la balota, se debeverificar si el número de la balota está presente en el tablero. Si es así, se debeactualizar el tablero, poniendo a la variable seleccionado de la posición donde seencuentra en uno.
publicvoid actualizarTablero(int aleatorio) {for(int i=0; i<matriz.length; i++){
for (int j=0; j<matriz.length; j++) {if(matriz[i][j].getNumero()==aleatorio) {matriz[i][j].setSeleccionado(1); }}}}
Finalmente, algunos de los métodos de la clase Bingo se presentan acontinuación:El métodocrearTablero generaun nuevo tablero con números aleatorios y por últimoverifica que el creado no haya sido generado con anterioridad.
public Tablero crearTablero(String telefono, Stringnombre, String cedula) {boolean centinela=true;
while(centinela){int inicio=0, finaliza=9, aleatorio;boolean res=false;Tablero miTablero=new Tablero(misTableros.size()+1);
for (int j=0; j<CANTIDAD_FILAS;j++){inicio=j*10;finaliza=inicio+9;
for (int i=0; i<CANTIDAD_FILAS; i++) { res=false;while(res==false)
{do{aleatorio= (int)(Math.random()*finaliza); }while(!(aleatorio>=inicio&&aleatorio<=finaliza));
res=miTablero.modificarNumero(j,i, aleatorio); }}
}if(verificarTableroValido(miTablero)==true) {
miTablero.setMiPropietario(telefono, nombre, cedula);misTableros.add(miTablero);centinela=false;
return miTablero;}}returnnull;
}
El método generarPosicion, es el encargado de seleccionar una nueva balota connúmero entre 0 y 49. Las balotas que ya se han seleccionado se van almacenandopara evitar repeticiones.
public Posicion generarPosicion() {if(hayGanador()==null){char letra[]={'B','I','N','G','O'}; int rango=0,aleatorio=0;boolean centinela=false;while(centinela==false)
{aleatorio= (int)(Math.random()*49);rango=0;
if (aleatorio>=10&&rango<=19)rango=1;if(aleatorio>=20&&rango<=29)rango=2;if(aleatorio>=30&&rango<=39)rango=3;if(aleatorio>=40&&rango<=49)rango=4;if(aleatorio!=0&&!posicionesGanadoras.contains(aleator{posicionesGanadoras.add(aleatorio);actualizarTodosLosTableros(aleatorio);
centinela=true;}
}Posicion p=new Posicion(aleatorio,0);p.setLetra(letra[rango]);return p;}returnnull;}
El método hayGanador() se encarga de verificar si alguien ya hizo bingo, es decirha cubierto completamente los 25 números de su tablero. public ArrayList<Integer> hayGanador() {ArrayList<Integer> ganadores=new ArrayList<Integer>();for(int i=0; i<misTableros.size(); i++) {if(misTableros.get(i).contarAciertos()==25)
{ganadores.add(i+1);}}if(ganadores.size()>0)return ganadores;elsereturnnull;
}
El método actualizarTodosLosTableros se encarga de actualizar los tableros conbase en la balota seleccionada aleatoriamente por el sistema. La actualizaciónconsiste en registrar, en el caso de tableros que tienen el número de la balota unacierto.
publicint actualizarTodosLosTableros(int aleatorio) {for(int i=0; i<misTableros.size(); i++) {
ACTIVIDADComplete la tabla siguiente con los requisitos funcionales que hacen faltaRequisito funcional 1 NombreDescripción EntradaRequisito funcional 2Requisito funcional 3Requisito funcional 4
Requisito funcional 5 SalidaNombreDescripción
EntradaSalidaNombreDescripción EntradaSalidaNombreDescripción EntradaSalidaNombreDescripción EntradaSalidaRealizar una jugadaUno de los jugadores selecciona una posición del tablero 1) valor en la fila,2) valoren la columna, 3) nickName de quien realiza la jugadaNingunaVerificar si hay ganador del triquiLuego de que se ha realizado una jugada se deberá verificar si se hizo triqui.NingunaEl nombre del jugador que hizo triqui, si lo hay.
4.2 Compr ensión del mundo del pr oblemaSe pueden identificar diferentes entidades, a saber: Triqui, Posicion y Jugador
* Es el valor en la fila*/privateint i;/**
* Es el valor en la columna*/privateint j;/*** Es el jugador que dio clic en esa posicion*/private Jugador miJugador;}
El constructor de la clase recibe respectivamente la columna y la fila queconforman la posición.
public Posicion(int i, int j) { super();this.i = i;this.j = j;verificarInvariante();
}
El método setMiJugador permite fijar el jugador en la posicion
publicvoid setMiJugador(Jugador miJugador) {this.miJugador = miJugador;}
Por otra parte, la clase Jugador tiene entre otros métodos los siguientes:El constructor que permite inicializar el nombre y Nick del jugador
public Jugador(String nombre, String nick) { super();
this.nombre = nombre;this.nick = nick;}
El método equals, que verifica si dos objetos son iguales.
publicboolean equals(Object objeto) { if ( this == objeto ) returntrue;
if ( objeto == null ) returnfalse; if ( this.getClass() != objeto.getClass() )returnfalse;
if ( this.nombre== this.getClass().cast(objeto).nombre&&this.nick== this.getClass().cast(objeto).nick ) returntrue;
if ( this.nombre != null&&this.nick!=null) if( this.nombre.equals(this.getClass().cast(objeto).nombre)&&this.nick.equals( this.getClass().cast(objeto).nick))returntrue;
if ( this.nombre != null&&this.nick==null) if( this.nombre.equals(this.getClass().cast(objeto).nombre )) returntrue;
if (this.nick==null) if( this.nick.equals(this.getClass().cast(objeto).nick)) returntrue;
returnfalse ; }}
Finalmente, se tiene la clase Triqui. Algunos de sus métodos son:El método constructor, en el que se le reserva memoria a la matriz y también acada uno de las posiciones dentro de la matriz.
public Triqui(){misPosiciones=new Posicion[3][3];
for (int i=0; i<misPosiciones.length; i++) {for(int j=0; j<misPosiciones[0].length; j++) {misPosiciones[i][j]=new Posicion();misPosiciones[i][j].setI(i);misPosiciones[i][j].setJ(j);}}}
El método jugar recibe la fila y la columna de la celda que el usuario seleccionó ytambién su nickName. El método lo que hace es marcar la posición comoseleccionada. Por último, identifica cual es el jugador que debe realizar la próx imajugada.
public Jugador jugar(int i, int j, String nickName) {centinela=false;if(misPosiciones[i][j].getMiJugador()==null&& turnoJugador.getNick().equals(nickName)){misPosiciones[i][j].setMiJugador(buscarJugador(nickName));turnoJugador=buscarJugadorContrario(nickName);centinela=true;return verificarTriqui();}
returnnull;}
Finalmente, el método verificarTriqui() verifica si se realizó triqui en la diagonalprincipal, en la diagonal secundaria, en la columnas o en las filas.
public Jugador verificarTriqui(){int i;//Triqui en la diagonal principalif( misPosiciones[0][ 0 ].getMiJugador()!=null&&misPosiciones[2][2].getMiJugador()!=null&&misPosiciones[1 ][1].getMiJugador()!=null&&misPosiciones[ 0 ][0].getMiJugador().getNick().equals(misPosiciones[2][2].getMiJugador().getNick()) && misPosiciones[0][0].getMiJugador().getNick().equals(misPosiciones[1][1].getMiJuga dor().getNick())){ return misPosiciones[ 0 ][ 0 ].getMiJugador();}
//Triqui en la otra diagonal if( misPosiciones[0][ 2 ].getMiJugador()!=null&&misPosiciones[1][1].getMiJugador()!=null &&misPosiciones[ 2 ][ 0].getMiJugador()!=null&&misPosiciones[ 0 ][ 2].getMiJugador().getNick().equals( misPosiciones[ 1 ][1 ].getMiJugador().getNick()) && misPosiciones[ 0 ][ 2].getMiJugador().getNick().equals( misPosiciones[ 2 ]
[0 ].getMiJugador().getNick())){ return misPosiciones[ 0 ][ 0 ].getMiJugador();}
for( i = 0 ; i < 3 ; i++ ) {
if ( misPosiciones[i][ 0 ].getMiJugador()!=null&&misPosiciones[i][1].getMiJugador()!=null&&misPosiciones[ i ][ 2 ].getMiJugador()!=null&&misPosiciones[ i ][ 0].getMiJugador().getNick().equals(misPosiciones[ i ][ 2 ].getMiJugador().getNick()) &&misPosiciones[ i ][ 0].getMiJugador().getNick().equals(misPosiciones[ i ][ 1 ].getMiJugador().getNick())){ return misPosiciones[ i ][ 0 ].getMiJugador();}}for( i = 0 ; i < 3 ; i++ ){ if( misPosiciones[0][i ].getMiJugador()!=null&&misPosiciones[1][i].getMiJugador()!=null&&misPosiciones[ 2 ][ i].getMiJugador()!=null&&misPosiciones[0][i].getMiJugador().getNick().equals(misP osiciones[ 1][ i ].getMiJugador().getNick()) &&misPosiciones[ 1 ][ i ].getMiJugador().getNick(). equals(misPosiciones[2][i].getMiJugador().getNick())){
return misPosiciones[ 0 ][ i ].getMiJugador();}}returnnull;}
5 Hoja de Tr abajo N.2 Concéntr ese (Código Fuente:unidadIIIHoja02JuegoPar ejas)Se desea crear una aplicación para el juego de parejas. El juego consiste enseleccionar consecutivamenente dos casillas sobre un tablero, buscando parejasde fotos.
en el tablero con su respectiva pareja de forma aleatoria. NingunaUn nuevo tablero ha sido creadoRealizar jugada Se debe seleccionar una casilla en el tablero. Cada vez que se hayanseleccionado números pares de casillas se deberá verificar si el jugador encontróuna pareja o no. 1) fila 2)columnaSi se halló una pareja se devuelven las dos últimas jugadas realizadas, sino nose devuelve nullCalcular el puntaje totalLuego de que el usuario encuentra una pareja, dependiendo de los iconos halladosse acumula el puntaje obtenidoNingunaEl puntaje obtenido
5.2 Compr ensión del mundo del pr oblemaSe pueden identificar diferentes entidades, a saber: Juego, Posicion e Icono.
mismo icono.
publicclass Icono {//----------------------------------------------------------------//Atributos//----------------------------------------------------------------/**
* Es el nombre del icono*/private String nombre;/*** Es el estado del icono*/privateboolean estado;/*** Es el puntaje que da este icono*/privateint puntaje;}
En esta clase además del método constructor, que inicializa los atributos de laclase se cuenta con los métodos get y set para los atributos.
public Icono(String nombre, boolean estado, intpuntaje) { this.nombre = nombre;this.estado = estado;this.puntaje=puntaje;verificarInvariante();
}
La siguiente clase es la clase Posicion, cuyos atributos se muestran a
continuación.
publicclass Posicion {//----------------------------------------------------------------// Atributos//----------------------------------------------------------------/*** Es el valor en la fila*/privateint i;/*** Es el valor en la columna*/privateint j;
/*** Es el estado del icono*/
privateint estado;/*** Es la ruta de la foto del icono */private Icono foto;}
Esta clase tiene,entre otros métodos, un constructor que permite inicializar losatributos i, j y estado. Además tiene el método setFoto, el cual permite iniciar elatributo foto.
public Posicion(int i, int j, int estado) { this.i =i;this.j = j;this.estado = estado;
verificarInvariante();
}
publicvoid setFoto(Icono miIcono) { this.foto =miIcono;}
Finalmente, la clase Juego tiene un método constructor en el cual se le reservamemoria al tablero apoyándonse en el método inicializarFotos y crearMatriz.
public Juego() {misFotos=new ArrayList<Icono>();misPosiciones=new Posicion[TAMANIO][TAMANIO];dosUltimasJugadas=new ArrayList<Posicion>();inicializarFotos();crearMatriz();verificarInvariante();}
publicvoid inicializarFotos(){//Se agregan al ArrayList las diferentes fotosmisFotos.add(new Icono("fotos/baby1.jpg",false,2));misFotos.add(newIcono("fotos/cupeiro1.jpg",false,-5));misFotos.add(new Icono("fotos/flor1.jpg",false,3));misFotos.add(new Icono("fotos/hongo1.jpg",false,3));misFotos.add(newIcono("fotos/honguito1.jpg",false,4));misFotos.add(new Icono("fotos/images1.jpg",false,-8));misFotos.add(new Icono("fotos/mario1.jpg",false,5));misFotos.add(newIcono("fotos/orejitas1.jpg",false,3));
misFotos.add(new Icono("fotos/pez1.jpg",false,2));misFotos.add(newIcono("fotos/princess1.jpg",false,4));misFotos.add(newIcono("fotos/rosalina1.jpg",false,2));misFotos.add(new Icono("fotos/luigi1.jpg",false,4)); }
En el método crearMatriz se crean cada una de las posiciones del tablero y a cadacelda se le asigna un icono. Siempre que se ponga un icono en una posicion sedebe poner en otra celda ese mismo icono, pues se requiere formar parejas. Laselección de los iconos debe ser aleatoria.La única posición a la que no se lepone ícono es la posición [2][2].
publicvoid crearMatriz(){do{int x=0, y=0, icono=0;boolean centinela=false;ArrayList<Integer> posicionesIconos=newArrayList<Integer>(); int contador=0;//Se crean todas las posicionesfor(int i=0; i<misPosiciones.length; i++){
for(int j=0; j<misPosiciones[0].length; j++)
{misPosiciones[i][j]=new Posicion(i,j,0) ;}}//Aqui se asignan los iconos
}
permanente. Construir un programa completo, siguiendo todas las etapas requeridas pararesolver un problema. Construir pruebas unitarias que permitan probar el correcto funcionamiento delsoftware2 Motivación
En la vida real se presentan muchos casos en los cuales se requiere manejar elestado inicial de un problema y que esta información sea leida a través de unarchivo Para poder dar respuesta a esta necesidad en este nivel se tratará el temade archivos Properties y serialización.
3 Caso de estudio N.1La Empr esa (Código Fuente:unidadIVCaso01Empr esa)
Se desea crear una aplicación para manejar la información de una empresa. En laempresa hay empleados. Cada uno tiene un codigo, un nombre, una fecha denacimiento y un salario. La aplicación debe permitir:- Agregar un nuevo empleado- Leer la información de la empresa de un archivo de entrada.- Generar un archivo con la información de la empresa- Obtener la edad promedio de los empleados- Mostrar la información de los empleados ordenada por salario utilizando elmétodo de inserción- Mostrar la información de los empleados ordenada por edad utilizando el métodode selección.- Buscar empleado que tenga el salario especificado por el usuario
Descripción EntradaSalida
Requisito funcional 4
Requisito funcional 5 NombreDescripción EntradaSalidaNombreDescripción
Requisito funcional 6 EntradaSalidaNombreDescripción
Requisito funcional 7 EntradaSalidaNombreDescripción
Entrada SalidaAgregar un nuevo empleadoSe requiere añadir un nuevo empleado1)id, 2)nombre, 3)dia, 4) mes, 5)anio,6)salarioUn nuevo empleado ha sido agregado a la empresaLeer la información de la empresa de un archivo de entrada. La información de laempresa se lee desde el archivo y constituye el estado inicial de la empresaNombre del archivo con la información de la empresaSe inicializó el estado de la empresa, a partir de lo que se encontraba almacenadoen el archivo.
Generar un archivo con la información de la empresaSe requiere generar un archivo con la información de la empresa Nombre delarchivo de la salidaUn nuevo archivo ha sido generado con la información de la empresaObtener la edad promedio de los empleadosSe requiere obtener la edad promedio de los empleados NingunaLa edad promedioMostrar la información de los empleados ordenada por salario Se requiere generarun listado con la información de los empleados ordenada por salario. Para resolvereste requisito se hará uso del método de inserción.NingunaEl listado ordenado por salarioMostrar la información de los empleados ordenada por edad Se requiere generar unlistado con la información de los empleados ordenada por edad. Para resolver esterequisito se hará uso del método de selección.NingunaEl listado ordenado por edadBuscar empleado que tenga el salario especificado por el usuario Se requierebuscar el primer empleado que tenga el salario especificado por el usuario,utilizando el método de búsqueda binaria.El salario buscadoUn empleado que tenga el salario buscado
3.2 Compr ensión del mundo del pr oblemaSe pueden identificar diferentes entidades, a saber: Empresa, Empleado y Fecha.
3.3 Diseño y constr ucción de la solución del pr oblemaDado que la clase Empresa contiene la información de los empleados, esta clasees la responsable de:
- Dar la información de los empleados- Dar la edad promedio de los empleados- Dar el listado de los empleados ordenada por salario y por edad- Dar el empleado que tenga el salario especificado por el usuario- Generar un archivo con la información de la empresa.
Esta clase también tiene las siguientes responsabilidades referentes a lamodificación de su estado:- Registrar un nuevo empleado- Leer desde un archivo la información de la empresa y guardarla en el ArrayList deempleados.Con base en las anteriores responsabilidades identificadas se definirán losmétodos de la clase Empresa.3.4 Ar chivos
Un archivo es una colección de información almacenada como una unidad enalgún dispositivo de almacenamiento secundario. Entre las características másgenerales de los archivos se tienen las siguientes:
* Nombre y ex tensión: Todo archivo debe tener nombre y una ex tensión. Laex tensión indica su formato. * Datos sobre el archivo: por cada archivo se almacena datos relacionados,talescomo: tamaño, fecha de creación, modificación y de último acceso,
* Ubicación, ruta o path: Todo archivo está ubicado dentro de una carpeta osubcarpeta. El path de un archivo suele iniciar con la unidad lógica que locontiene, seguida de las sucesivascarpetas hasta llegar al directorio que loalmacena, por ejemplo:
"C:\eclipse\plugins\edu buffalo.cse.green.relationship.association.source_3.5.0".
Desde java es posible cargar la información de los archivos almacenados endisco. Los archivos que se manejarán en los siguientes casos de estudio tienenun formato especial, que recibe el nombre de properties. Un archivo con ex tensión properties es utilizado principalmente para almacenarparámetros de configuración de una aplicación. Tambiénse puede utilizar paraalmacenarcadenasparala internacionalizaciónylocalización.
Cadaparámetrosealmacenacomo unpareja de Strings, el primero almacenarelnombredelparámetro(llamado clave), yel segundo, el valor.A continuación se muestra el formato del archivo que se utilizará:Nombre Valor de la propiedad
empleados propertiesempresa.empleados=5empresa.empleado0=1234,Juan Perez,23-02-1987,324345empresa.empleado1=65643,Maria Perez,23-02-1987,4545empresa.empleado2=443,Rocio Rosero,23-02-1987,3332empresa.empleado3=12439,Liliana Rodriguez,23-02-1987,435 empresa.empleado4=5643,Diana Lopez, 23-02-1987,3232
Cada línea dentro del archivo corresponde a una propiedad. Para poder aplicar el concepto de properties al caso de estudio de la empresa enla ventanaPrinicipal se requiere agregar el siguiente método:publicvoid cargarEmpleados( ) throws Exception {
JFileChooser fc = new JFileChooser( "./data" );fc.setDialogTitle( "Abrir archivo de empleados" ); intresultado = fc.showOpenDialog( this );if( resultado == JFileChooser.APPROVE_OPTION ) {
inicializarEmpleados(datos);}
El método cargarInfoEmpresa se encarga de cargar la información de losempleados de la empresa en un objeto de tipo Properties, recibe como parámetroel archivo que contiene la descripción de los empleados de la empresa y devuelveun objeto de la clase Properties con la información del archivo.
private Properties cargarInfoEmpresa( File arch )throws Exception {Properties datos = new Properties( );FileInputStream in = new FileInputStream( arch );try{ datos.load( in );in.close( );}catch( Exception e ){thrownew Exception( "Formato inválido" );}return datos;}
El método inicializarEmpleados tiene como función inicializar el arreglo deempleados con la información que recibe en el parámetro de entrada. Tiene comoparámetro una un objeto de tipo Properties, al cual se le llamó datos. En datos estála información cargada del archivo para inicializar la empresa.
privatevoid inicializarEmpleados( Properties datos )throws Exception {//A medida que se cargan los empleados se llenará unarchivo log //con el reporte de los problemasocurridos.
FileWriter salida=null;BufferedWriter salida1=null;salida=new FileWriter("./data/logCarga.txt");salida1=new BufferedWriter(salida);copiarLineaEnArchivoLog("En el proceso se generaronlos siguientes errores: ", salida1);copiarLineaEnArchivoLog("\n", salida1);//Se inicia el proceso de carga del archivo String strNumeroEmpleados = datos.getProperty("empresa.empleados" ); int maxEmpleados =Integer.parseInt( strNumeroEmpleados );int idConfirmacion=0;// Lee el nombre de cada empleados de la respectivapropiedad y crea el objeto que lo representafor( int i = 0; i < maxEmpleados; i++ ){String id="",nombre="";int dia=0, mes=0, anio=0;double salario=0;String infoEmpleado = datos.getProperty("empresa.empleado" + i ); StringTokenizer st2=newStringTokenizer(infoEmpleado,"-,");
for (int j=0; st2.hasMoreTokens(); j++) { String elemento=st2.nextToken().trim(); if(j==0)
id=(elemento);elseif(j==1)
nombre=(elemento);elseif(j==2)
dia=Integer. parseInt(elemento); elseif(j==3) mes=Integer.parseInt(elemento);elseif(j==4)anio=Integer.parseInt(elemento); elsesalario=Double.parseDouble(elemento);
}idConfirmacion=Integer.parseInt(id);try{
agregarEmpleado(id, nombre, dia, mes, anio, salario) ;}catch(Exception e){copiarLineaEnArchivoLog("Id "+id+" Nombre "+nombre+"Fecha "+dia+"/"+mes+"/"+anio+" Salario: "+salario,salida1); }
}salida1.close(); }
copiarLineaEnArchivoLog se encarga de registrar los errors ocurridos durante elproceso de carga.
publicvoid copiarLineaEnArchivoLog(String linea,BufferedWriter salida1)throws Exception{
salida1.write("\n"); salida1.write(linea);salida1.write("\n");
}
El método generarProperties recorre el ArrayList de empleados y va tomando cadaempleado para poder agregar una nueva línea al archivo.
publicvoid generarProperties(String nombreArch) throwsException {FileWriter salida=null;BufferedWriter salida2=null;salida=new FileWriter(nombreArch);salida2=new BufferedWriter(salida);copiarLineaEnArchivoLog("empresa.empleados="+misEmpleadsalida2); for(int i=0; i<misEmpleados.size(); i++){String id=misEmpleados.get(i).getId();String nombre=misEmpleados.get(i).getNombre();Stringfecha=misEmpleados.get(i).getMiFechaNacimiento().getDia"+misEmpleados.get(i).getMiFechaNacimiento().getAnio()double salario=misEmpleados.get(i).getSalario();String total=id+","+nombre+","+fecha+","+salario;System.out.println(total);salida2.write("\n");salida2.write("empresa.empleado"+i+"="+total);salida2.write("\n");}salida2.close();}
3.5 Métodos de or denamiento y búsqueda
El método de Inserción directa se basa en tomar uno por uno los elementos de unarreglo 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 dosanteriores, así sucesivamente hasta recorrer todas las posiciones del arreglo.
public String[] ordenarPorInsercionSalario() {
String array[]= new String[misEmpleados.size()];Empleado temp;int i,j;for (i=0; i<misEmpleados.size(); i++){
temp = misEmpleados.get(i); for (j=i; j>0;j--) {if ( misEmpleados.get(j-1).getSalario()<=temp.getSalario()) break;
misEmpleados.set(j,misEmpleados.get(j-1)); }misEmpleados.set(j,temp);
}for(i=0; i<misEmpleados.size(); i++) {array[i]=misEmpleados.get(i).getId()+"
"+misEmpleados.get(i).getNombre()+ " Edad: "+misEmpleados.get(i).calcularEdad()+ "Salario: "+misEmpleados.get(i).getSalario();}
return array; }
ACTIVIDAD
Básese en este código para llenar la siguiente tabla y al final escriba un
comentario en torno a cómo funciona el algoritmo.Otro método muy conocido es el de Selección, el cual consiste en encontrar elmenor de todos los elementos del arreglo e intercambiarlo con el que está en laprimera posición. Luego el segundo más pequeño, y así sucesivamente hastaordenar todo el arreglo
public String [] ordenarEdadPorSeleccion() {
String array[]= new String[misEmpleados.size()];Empleado temp;int i,j;for (i=0; i<misEmpleados.size()-1; i++) {
for (j=i+1; j<misEmpleados.size();j++) {if ( misEmpleados.get(i).calcularEdad()>misEmpleados.get(j).calcularEdad()) {temp =misEmpleados.get(i); misEmpleados.set(i,misEmpleados.get(j));misEmpleados.set(j,temp);}}
}for(i=0; i<misEmpleados.size(); i++) {array[i]=misEmpleados.get(i).getId()+"
"+misEmpleados.get(i).getNombre()+ " Edad: "+misEmpleados.get(i).calcularEdad()+ "Salario: "+misEmpleados.get(i).getSalario();}
return array; }
ACTIVIDAD
Básese en ordenarEdadPorSeleccion() para llenar la siguiente tabla y al finalescriba un comentario en torno a cómo funciona el algoritmo.Para buscar un elemento dentro de un arreglo se puede utilizar la técnica debúsqueda binaria. Esta técnica requiere que los elementos del arreglo ya seencuentran ordenados. Su funcionamiento es el siguiente:Para iniciar lo que se hace es tomar un elemento central (el encuentra a la mitaddel arreglo), y se compara con el elemento buscado. En caso de que el elementobuscado sea menor, se selecciona el intervalo que va desde el elemento central alprincipio, de lo contrario, se elegirá el intervalo que va desde el elemento centralhasta el final del intervalo.
Este proceso se repetirá sucesivamente hasta que se llegué a un intervaloindivisible, que indique si el elemento buscado está o no en el vector. El código esel siguiente:
public Empleado busquedaBinaria(double salario) {DecimalFormat formatoDecimal;int inicio, fin, medio;inicio=0;fin=misEmpleados.size()-1;ordenarPorInsercionSalario();formatoDecimal = new DecimalFormat ( "0.0" ); Stringdato= formatoDecimal.format ( salario);dato=dato.replace(',','.');salario=Double.parseDouble(dato);
while(inicio<=fin)
{medio=(inicio+fin)/2;if(salario==misEmpleados.get(medio).getSalario())
return (misEmpleados.get(medio));elseif(salario>misEmpleados.get(medio).getSalario())inicio=medio+1;elsefin=medio-1;
}returnnull; }
ACTIVIDADAplique el método de busquedaBinaria para hallar a 5.3.5 Pr uebas de softwar e
Las pruebas o test son utilizadas durante el desarrollo de software para identificarposibles errores y revelar el grado de cumplimiento en relación a lasespecificaciones que inicialmente se plantearon para el sistema. Las pruebascontribuyen a garantizar la calidad del software construido.
En Java se dispone del Framework JUnit para la realización y automatización depruebas. Para crear una clase de prueba ubíquese en el paquete test, de clic sobreél y seleccione JUnit Test Case.
tearDownAfterClass: Únicamente puede haber un método con esta marca. Seejecuta una sóla vez cuando ha finalizado la ejecución de todas las pruebas.tearDown:Seejecutadespuésde ejecutarse cada prueba. Este método se sustituyepor la anotación @After.setUp: Se invoca antes de ejecutarcada prueba. Este método se sustituyó por laanotación @BeforeTambién puede usarse otras etiquetas:Test: Se le coloca @Test a la prueba que se va a ejecutarIgnore: El método que tenga esta marca no será ejecutado.Retomando la creación de la clase de prueba para Empleado de clic en Nex t.Luego seleccione los métodos donde se modifica el estado del objeto:constructores, set o donde se realicen cálculos.
Para este caso se seleccionarán los siguientes métodos:Empleado(String, String, int, int, int, double)calcularEdad()
publicclass EmpleadoTest {//----------------------------------------------------------------// Atributos//----------------------------------------------------------------
/*** Es la clase donde se realizarán las pruebas */private Empleado miEmpleado;
//----------------------------------------------------------------// Métodos//----------------------------------------------------------------
/*** Construye un nuevo empleado */@Beforepublicvoid setupEscenario1( ) {
miEmpleado= new Empleado("123", "luis", 23, 02, 1980,5000000); }
/*** Prueba del constructor */
@Testpublicvoid testEmpleado() {assertEquals( "El codigo es inválido.","123",miEmpleado.getId() ); assertEquals( "El nombrees inválido.", "luis",miEmpleado.getNombre() );assertEquals( "El dia esinválido.",23,miEmpleado.getMiFechaNacimiento().getDia);
assertEquals( "El mes es inválido.", 02,miEmpleado.getMiFechaNacimiento().getMes() );assertEquals( "El anio es inválido.", 1980 ,miEmpleado.getMiFechaNacimiento().getAnio() );assertEquals( "El salario es inválido.",5000000,miEmpleado.getSalario(),0 ); }
@Testpublicvoid testCalcularEdad() {assertEquals( "El salario es inválido.",31,miEmpleado.calcularEdad() ); }}
Para ejecutar las pruebas de clic en Run As JUnit Test
implementados*/
publicclass FechaTest {//----------------------------------------------------------------// Atributos//----------------------------------------------------------------
/*** Es la clase donde se realizarán las pruebas */private Fecha miFecha;
//----------------------------------------------------------------// Métodos//----------------------------------------------------------------
/*** Construye una nueva fecha */@Beforepublicvoid setupEscenario1( ) {
miFecha= new Fecha(23,02,1980); }
/*** Prueba del constructor*/@Testpublicvoid testFechaIntIntInt() {assertEquals( "El dia es inválido.",23,miFecha.getDia() );
assertEquals( "El mes es inválido.",
02,miFecha.getMes() ); assertEquals( "El anio esinválido.", 1980 ,miFecha.getAnio() );
}@Testpublicvoid testSetDia() {miFecha.setDia(24);assertEquals( "El dia es inválido.",24,miFecha.getDia() ); }
@Testpublicvoid testSetMes() {miFecha.setMes(03);assertEquals( "El mes es inválido.",03,miFecha.getMes() ); }
@Testpublicvoid testSetAnio() {miFecha.setAnio(1981);assertEquals( "El anio es inválido.", 1981,miFecha.getAnio() ); }
@Testpublicvoid testCalcularDiferenciaConFechaActual() {assertEquals( "La diferencia es incorrecta.", 373 ,miFecha.calcularDiferenciaConFechaActual(newFecha(24,03,2010))); }}
4 Caso de estudio N.2 La Libr eta Telefónica (CódigoFuente:unidadIVCaso02Libr etaTelefonica)Se requiere una aplicación para manejar una libreta telefónica en la cual seaposible registrar la información de varios contactos. La aplicación debe permitir:
- Agregar un nuevo contacto
- Leer la información de la libreta de un archivo de entrada.- Almacenar la información de forma persistente haciendo uso del concepto deserialización.- Eliminar un contacto indicando su posición- Modificar un contacto
4.1 Requisitos funcionalesPara resolver este caso de estudio nos centraremos en los siguientes requisitos:Requisito funcional 1
Requisito funcional 2 NombreDescripción
EntradaSalidaNombreDescripción
Entrada Salida
Requisito no funcional Tipo: Persistencia Agregar un nuevo contactoSe debe agregar un nuevo contacto, para ello se debe ingresar el nombre, ladirección y el listado de teléfonos1) nombre, 2) dirección 3) el listado de teléfonosSe ha agregado un nuevo contactoLeer la información de la libreta de un archivo de entrada. La información de lalibreta se lee desde el archivo y constituye el estado inicial de la libretaNombre del archivo con la información de la libretaSe inicializó el estado de la libreta, a partir de lo que se encontraba almacenadoen el archivo.
La información del modelo del mundo debe persistente. Ello se logra haciendo usode archivos de .dat
4.2 Compr ensión del mundo del pr oblemaSe pueden identificar diferentes entidades, a saber: Libreta, Contacto,ContactoRepetidoEx ception y Entidad. Esta última ser á la encar gada demanejar todo lo r efer ente a ser ializac ión.
publicvoid agregarContacto(String nombre, Stringdireccion,ArrayList<String> misTelefonos) throwsContactoRepetidoException{
nombre=nombre.toUpperCase();if(buscarContacto(nombre)==-1)misContactos.add(new Contacto(nombre,direccion,misTelefonos)); elsethrownew ContactoRepetidoException("El contacto yaexiste"); }
La clase ContactoRepetidoEx ception hereda de la clase Ex ception. Dentro de ellase llama al constructor de la superclase para poder inicializar la variable messagecon el mensaje que se le mostrará al usuario.
Ex ception es la clase base de la que derivan todas las ex cepciones. Se podríaconcluir entonces que a través de ContactoRepetidoEx ception es posible crearinstancias de objetos de Ex ception.publicclass ContactoRepetidoException extendsException {
public ContactoRepetidoException (String message) {super(message);}}
Para resolver el requerimiento de cargar la información de la libreta desde unarchivo será necesario apoyarse en los Properties. En la clase Libreta deben ir los3 siguientes métodos:
publicvoid cargar( File arch ) throws Exception {Properties datos = cargarInfoLibreta( arch );
inicializarContactos(datos);}
El método cargarInfoLibreta se encarga de cargar la información de los empleadosde la empresa en un objeto de tipo Properties.
private Properties cargarInfoLibreta( File arch )throws Exception {Properties datos = new Properties( );FileInputStream in = new FileInputStream( arch );try{ datos.load( in );in.close( );}catch( Exception e ){thrownew Exception( "Formato inválido" );}return datos;}
El método inicializarContactos es el encargado de inicializar el arreglo decontactos con la información que recibe en el parámetro de entrada. Este métodotiene como parámetro a datos. datos contiene la información cargada del archivopara inicializar la libreta.
privatevoid inicializarContactos( Properties datos )throws Exception {ArrayList <String> misTelefonos=new ArrayList<String>();//Se inicia el proceso de carga del archivo String strNumeroContactos = datos.getProperty("libreta.contactos" ); int maxEmpleados =
Integer.parseInt( strNumeroContactos );// Lee el nombre de cada persona de la respectivapropiedad y crea el objeto que //lo representa
for ( int i = 0; i < maxEmpleados; i++ ) {String direccion="",nombre="";String infoEmpleado = datos.getProperty("libreta.contacto" + i ); StringTokenizer st2=newStringTokenizer(infoEmpleado,"[,]");
for (int j=0; st2.hasMoreTokens(); j++) { String elemento=st2.nextToken().trim(); if(j==0)
nombre=(elemento);elseif(j==1)direccion=(elemento);else{ int telefono=Integer.parseInt(elemento);
misTelefonos.add(elemento);}}
try {agregarContacto(nombre, direccion, misTelefonos);
} catch(Exception e){}misTelefonos=new ArrayList<String>();
} }
Por otro lado, en la VentanaPrincipal debe ir el método cargarContactos. Estemétodo es el que carga los empleados a partir de un archivo seleccionado por elusuario
/** Carga los empleados a partir de un archivoseleccionado por el usuario * @throws Exception */publicvoid cargarContactos( ) throws Exception{JFileChooser fc = new JFileChooser( "./data" );fc.setDialogTitle( "Abrir archivo de contactos" );int resultado = fc.showOpenDialog( this );if( resultado == JFileChooser.APPROVE_OPTION ){
File archivo = fc.getSelectedFile( );miLibreta.cargar(archivo);}}
Para resolver el requisito de ordenar por nombre en la clase se utilizará el métodoburbuja y la clase Collator, que ofrece más ventajas que el método compareTo.
public String[] listarContactosPorNombre(){String arreglo[]=new String[misContactos.size()];/*Collator posee unas constantes para trabajardiversos criterios relacionados con la comparación Collator.PRIMARY considera distintas dos letras si laletra base es distinta, por ejemplo si se tiene A, a yá, son iguales puesto que tiene la misma baseCollator.SECUNDARY sólo considera iguales lasmayúsculas y las minúsculas. No son iguales si tienen
tilde. Collator.TERCIARY Son completamente diferentes lastres letras. Collator.IDENTICALLY sólo son iguales si su codigointerno es el mismo. Por ejemplo, existenvarias formas de codificar internamente una á contilde. No obstante cada codificación sería diferenteaunque se vea igual.*/Collator comparador = Collator.getInstance(newLocale("es", "ES", "EURO")); // EURO es para estar aldia //Se configura para que ‘A’, ‘a’ y ‘á’ sean igualescomparador.setStrength(Collator.PRIMARY);for (int i = 0; i < misContactos.size(); i++) {for (int j = 0; j < misContactos.size()-1; j++) {
// Compare elements of the array two at a time.if(comparador.compare(misContactos.get(j).getNombre(), misContactos.get(j+1).getNombre() ) > 0 ) {
// Intercambia las palabrasContacto tmp = misContactos.get(j);misContactos.set(j,misContactos.get(j+1));
misContactos.set(j+1,tmp);;}}}
for (int i = 0; i < misContactos.size(); i++) {arreglo[i]=misContactos.get(i).toString(); }return arreglo;
}
4.4 Ser ializac ion
La serialización de objetos es una propiedad de Java a través de la cual esposible leer y escribir objetos en un archivo. Para serializar es necesario que cadauna de las clases del paquete mundo implemente la interfaz serializable, la cualobliga a que todos los campos de datos del objeto sean serializables. La interfazSerializable no tiene métodos, por ello su implementación es muy sencilla, bastacon colocar implements Serializable en cada clase. Ejemplo:
publicclass Contacto implements Serializable {}
Para serializar es necesario utilizar las clases ObjectInputStream yObjectOutputStream para leer y escribir los objetos.Si se desea especificarle a la máquina virtual de Java que un atributo no seráparte persistente de un objeto debe utilizarse el modificador transient.
Para automatizar el proceso de serialización se creó una clase “ genérica”llamada Entidad, la cual puede ser utilizada en cualquier aplicación que ustedconstruya para que le agregue esta funcionalidad.
La genericidad o parametrización surge a partir de Java 5 y su objetivo es permitirla creación de estructuras que almacenan elementos de un único tipo, siendo elcompilador quien se encarga de comprobar que no se presenten inconsistencias.Java también permite la creación de clases
genéricas. Siguiendo la sintax is: NombreClase<T1,…,Tn>. Ejemplo: Entidadque almacena objetos de tipo T
publicclass Entidad <T> {private T miObjeto; private String ruta;
public Entidad ( String ruta, T miObjeto) {this.ruta=ruta;this.miObjeto =miObjeto; // capacidad 0, contenidonada, incremento 0 }
Recibe un objeto de tipo T, para inicializar el atributo de la clase
public T load ( String nameFile ) throws Exception{
FileInputStream fileIn; Devuelve un objeto de tipo T con laObjectInputStream in; información que se cargó delarchivo T readFile;
try{fileIn = new FileInputStream ( nameFile );in = new ObjectInputStream ( fileIn );readFile = ( T ) (in.readObject());
}catch( Exception e ){ thrownew Exception("ERROR, no se pudo leer delarchivo");} return readFile;}
publicvoid leerDatosArchivo ( ) throws Exception {miObjeto = (T) load (ruta);}
}
La ex presión de instanciación para este tipo de clases debe llevar el identificadorcompleto del tipo que será creado, al igual que el argumento para los constructoresde dicho tipo. A esta clase se le reservará memoria en la VentanaPrincipal. Acontinuación se describen los pasos realizados.
En la VentanaPrincipal debe agregar un atributo de tipo Entidad:privatestatic Entidad <Libreta>miEntidad;
Esta línea quiere decir que se va a almacenar una libreta teléfonica, es decir, sedebe aclarar que es lo que se va a almacenar. Si la clase principal del mundo fuepor ejemplo Empresa, entonces la línea sería pr ivatestatic Entidad<Empresa>miEntidad;
En la VentanaPrincipal se requiere también agregar los siguientes métodos:
El método serializar tiene como parámetro la ruta donde está almacenado elarchivo. En caso de que el archivo no ex ista se crea uno nuevo, sino se carga lainformación del archivo y se le asigna a la libreta.
publicstaticvoid serializar(String ruta) throwsException {miEntidad = new Entidad <Libreta> (ruta,miLibreta );File fOrig = new File(ruta );if(!fOrig.exists ( ))
{miEntidad.save(ruta);}else{ miEntidad.leerDatosArchivo();miLibreta=miEntidad.getMiObjeto(); }
jList1.setListData(miLibreta.listarContactosPorNombre(}
El método guardar archivo almacena la información que hay en el mundo. publicvoid guardarArchivo() throws Exception {miEntidad.save(miEntidad.getRuta());}
5 Hoja de tr abajo N.1 El Ahor cado (Código Fuente:unidadIVHoja01Ahor cado)
Se requiere una aplicación para el juego del Ahorcado. El usuario podrá agregarpalabras al conjunto de palabras ex istentes. También deberá proporcionarse lafuncionalidad de cargar palabras de un archivo. De igual forma, la aplicacióndeberá ofrecer persistencia mediante serialización.Cuando el juego inicie el sistema seleccionará aleatoriamente una palabra delbanco de palabras ex istentes. El usuario ingresará una letra y el sistema verificarási está contenida dentro de la palabra seleccionada. Si el usuario se equivoca 4veces el juego se dará por perdido.
5.1 Requisitos funcionalesPara resolver este caso de estudio nos centraremos en los siguientes requisitos:Requisito funcional 1Requisito funcional 1
Requisito funcional 2 NombreDescripción EntradaSalidaNombreDescripción EntradaSalidaNombreDescripción
Entrada Salida
Requisito no funcional Tipo: Persistencia Agregar una palabra
Cargar palabras desde un archivo
jugarEl usuario ingresa una letra y se debe verificar si está o no contenida en la palabraque el sistema seleccionó aleatoriamente Una letraSi la letra está en la palabra se le informa al usuario las posiciones donde estáubicada la letra dentro de la palabra y se verifica si ya se completó la palabra,pues en este caso el juego terminaría. Si la letra no está entonces se contabilizaun nuevo errores y se verifica si ya completó los 4 errores.La información del modelo del mundo debe persistente. Ello se logra haciendo usode archivos de .dat
5.2 Compr ensión del mundo del pr oblemaSe pueden identificar diferentes entidades, a saber: 5.3 Diseño y constr ucción de la solución del pr oblemaEn la clase Ahorcado se debe crear un método que permita seleccionaraleatoriamente una palabra.
publicvoid iniciarJuego()throws SinPalabrasException{if(misPalabras.size()!=0){palabraSeleccionada=misPalabras.get((int)(Math.random()*(misPalabras.size()1)));palabra=newchar[palabraSeleccionada.length()];}else
thrownew SinPalabrasException("No hay palabrasalmacenadas"); }
El método agregarPalabra tiene como parámetro la palabra que el usuario deseaagregar al banco de palabras.
publicvoid agregarPalabra(String palabra) throwsPalabraRepetidaException {if(!misPalabras.contains(palabra))
{misPalabras.add(palabra);}elsethrownew PalabraRepetidaException("La palabra yaexiste"); }
El método jugar recibe una letra y mediante un for verifica si ésta se encuentracontenida en la palabra seleccionada aleatoriamente por el sistema.
publicboolean jugar(char letra){boolean centinela=false;System.out.println("letra "+letra+ " Seleccionada"+palabraSeleccionada); for(int i=0;i<palabraSeleccionada.length(); i++)
{if(letra==palabraSeleccionada.charAt(i)){palabra[i]=palabraSeleccionada.charAt(i);centinela=true;
}}if(centinela==false){contadorErrores++;}return centinela;
}
El método verificarGano recorre la palabra seleccionada y compara con cada unode los caracteres que hay en el arreglo de char llamado palabra.publicboolean verificarGano() {}
El método verificarGano compara el contador de errores con 4. Si son iguales elusuario ha perdido.publicboolean verificarPerdio(){
}
Para cargar las palabras desde el archivo Properties se deben incluir en la claseAhorcado los siguientes métodos:
publicvoid cargar( File arch ) throws Exception {Properties datos = cargarPalabras( arch );inicializarPalabras(datos);}
El método cargarPalabras se encarga de cargar cada una de las palabras delahorcado en un objeto de tipo Properties.
private Properties cargarPalabras( File arch ) throwsException {Properties datos = new Properties( );FileInputStream in = new FileInputStream( arch );try{ datos.load( in );in.close( );}catch( Exception e ){
thrownew Exception( "Formato inválido" );}return datos;}
El método inicializarPalabras inicializa el ahorcado con la información que recibeen el parámetro de entrada.
privatevoid inicializarPalabras( Properties datos )throws Exception {//Se inicia el proceso de carga del archivo
String strNumeroPalabras = datos.getProperty("ahorcado.palabras" ); int maxPalabras =Integer.parseInt( strNumeroPalabras );
// Lee cada palabra de la respectiva propiedad y creael objeto que lo representa for( int i = 0; i <maxPalabras; i++ ){//Complete
} }
Por otro lado, se cuenta con un archivo Properties en donde se encuentra la rutadel archivo en donde se va a serializar. Esta ruta se cargará a través de lossiguientes dos métodos, incluidos también en la clase Ahorcado.
public String cargarRutaSerializacion( File arch )throws Exception {
Properties datos = cargarPalabras( arch ); returninicializarRutaSerializacion(datos); }
private String inicializarRutaSerializacion(Properties datos ) throws Exception {//Se inicia el proceso de carga del archivo
String ruta= datos.getProperty( "ahorcado.ruta" );return ruta;}
El archivo ahorcado properties tiene la siguiente forma:ahorcado.ruta=./data/archivo.dat
En la VentanaPrincipal se debe declarar el siguiente atributo: privatestaticEntidad <Ahorcado>miEntidad;
Y también hay que agregar el siguiente método
publicstaticvoid serializar(String ruta) throwsException {miEntidad = new Entidad <Ahorcado> (ruta,miAhorcado );File fOrig = new File(ruta );if(!fOrig.exists ( ))
{miEntidad.save(ruta);}else{ miEntidad.leerDatosArchivo();miAhorcado=miEntidad.getMiObjeto(); }}
6 Caso de estudio N.2 La Tienda Paisa (Código Fuente:unidadIVHoja01TiendaPaisa)
Se desea crear una aplicación para manejar la información de un minimercado. Enel minimercado hay artículos, cada uno de los cuales tiene codigo, nombre,
2)nombre, 3)cantidad de Ex istencias y 4)precio Un nuevo artículo ha sidoagregadoGenerar venta o facturaSe debe permitir generar una nueva factura, para ello el cliente debe informarcuales son los artículos que desea adquirir y la cantidad correspondiente por cadauno de ellos. Se debe verificar que si ex ista la cantidad solicitada por el usuario.1)listado de articulo con la cantidad solicitada por cada uno de ellos Una nuevafactura se ha generadoLa información del modelo del mundo debe persistente. Ello se logra haciendo usode archivos de .dat
6.2 Compr ensión del mundo del pr oblemaSe pueden identificar diferentes entidades, a saber:
El método actualizarUltimoPedido permite actualizar la cantidad de ex istencias enel ArrayList general de pedidos, es decir, cuando se adquiere un artículo en elminimercado la cantidad de ex istencias de ese artículo debe disminuir.
public Pedido actualizarUltimoPedido(int cantidad)throwsNoHayExistenciasDisponiblesException{misPedidosCompraActual.get(misPedidosCompraActual.size1).setCantidadExistencias(cantidad);intpos=identificarYaExistePedido(misPedidosDisponibles, misPedidosCompraActual.get(misPedidosCompraActual.sizeif(pos!=-1){
if(misPedidosDisponibles.get(pos).getCantidadExistenciascantidad>=0&&misPedidosDisponibles.get(pos).getCantidad{misPedidosDisponibles.get(pos).setCantidadExistencias(mos).getCantidadExistencias()-cantidad);}else{misPedidosCompraActual.remove(misPedidosCompraActual.sthrownew NoHayExistenciasDisponiblesException("No hayexistencias disponibles de ese articulo");
}}returnmisPedidosCompraActual.get(misPedidosCompraActual.size
}
El método calcularPrecioTotalVenta recorre el ArrayList de la venta y calcula eltotal a pagar.
publicdouble calcularPrecioTotalVenta() {double acum=0;
for (int i=0; i<misPedidosCompraActual.size(); i++){acum+=(misPedidosCompraActual.get(i).getCantidadExistencias(ual.get(i).getPrecio());
}return acum; }
Finalmente, de la clase Tienda se tienen entre otros los siguientes métodos:El método agregarPedido agrega un nuevo pedido al ArrayList general de pedidos.Si el pedido ya ex iste se genera una ex cepción.
publicvoid agregarPedido(String codigo, String nombre,int cantidadExistencias, double precio)throwsYaEstaElPedidoException{if(buscarPedido(codigo)==-1){Pedido miP=newPedido(codigo,nombre,cantidadExistencias,precio);misPedidos.add(miP);}else
thrownew YaEstaElPedidoException("Este pedido ya
existe en el sistema"); }
El método crear Factura le reserva memoria a una nueva factura y la agrega alArrayList general de ventas.
publicvoid crearFactura() {Venta miVenta=new Venta(misPedidos);misVentas.add(miVenta);}
El método agregarPedidoALaFactura agrega un nuevo pedido a la factura que seencuentra ubicada en la última posición del ArrayList de ventas.
publicvoid agregarPedidoALaFactura(String codigo,String nombre, int cantidad,double precio)throwsNoHayExistenciasDisponiblesException {misVentas.get(misVentas.size()-1).agregarPedido(codigonombre, cantidad, precio);}
BIBLIOGRAFIA ARBOLEDA COBO, Liliana María.Programación en red con java. Cali, UniversidadICESI, 2004 BISHOP, Judy. Java Fundamentos de programación. Addison-Wesley. SegundaEdición. Madrid. 1999. ISBN: 84-7829-022-2. BOOCH. Object Oriented Analysis & Design With Applications. Prentice Hall,1998 BOOCH. UML El Lenguaje Unificado de Modelado. Addison Wesley CEBALLOS S ERRA, Francisco Javier. Java 2: curso de programación.Alfaomega, 2006. Méx ico DEJALÓN G. Javier y RODRÍGUEZ J. Ignacio, Aitor, Imaz. Aprenda Java como siestuviera en primero. Escuela Superior de Ingenieros Industriales. San Sebastian.
Enero 2000. DEITEL, H y DEITEl, P. Como programar en Java, Prentice Hall. Primera edición.Méx ico, 1994 ISBN: 970-17-0044-9. ECKEL, Bruce. Piensa en Java. Prentice-Hall, Pearson Educación. Segundaedicion. Madrid, 2003. ISBN: 84-205-3192-8. ER KSSON, H. UML 2 Toolkit. Indianapolis: Wiley 2004 FOWLER, Martín. UML, gota a gota. Addison Wesley Longman de Méx ico,SA deCV
Méx ico 1.999. ISBN: 968-44-364-1 Goodrich, Michael y Tamassia, Roberto. Estructuras de datos y algoritmos enJava. CECSA. Segunda edición. 2002
HURTADO G L, Sandra Victoria. Conceptos Avanzados de Programación conJAVA. Universidad ICESI, 2002 LEE, Richard. Practical Object Oriented Development with UML and Java.Prentice-hall, 2002. LEMAY, Laura. Cadenhead Rogers. Aprendiendo java en 21 días. Prentice Hall.ISBN: 970-17-0229-8. Mex ico.1999. 882570-9. RICHARDSON. Professional Java JDK 6. Wrox , 2007 0228-1. VILLALOBOS, Jorge. Introduccion a las Estructuras de Datos. Prentice Hall, 2008 VILLALOBOS S., Jorge A y CASALLAS, Rubby. Fundamentos de programaciónAprendizaje Activo Basado en casos. Prentice Hall. ISBN: 970-26-0846-5. 2006 ZHANG, Computer Graphics Using Java 2d & 3d,-Pearson, Enero de 2007.
