01 Caso a Resolver

8/17/2019 01 Caso a Resolver

1/5

POO U2 Evaluación

Página 1 de 5

Caso a resolver

En la vida real nos encontraremos con casos mucho más complicados que los que podemos

resolver en la escuela; en los que tendremos que combinar todas las operaciones de

conjuntos y los operadores y cláusulas Java disponibles.

En casos complicados es importante pensar antes de empezar a escribir código Java. A

continuación vamos a plantear un caso ciertamente complicado para ver cómo podemos

desglosar y resolver la consulta que necesitamos para obtener el resultado deseado.

Utilizaremos unas tablas creadas únicamente para este ejemplo y no representativas de un

sistema real. Tenemos una tabla principal llamada 'PC', con diferentes columnas

conteniendo cadenas de identificación de los diferentes componentes usados para el

ensamblado de diferentes modelos de PCs. Las columnas vacías de la tabla 'PC' significan

componentes no presentes en dichos modelos y se rellenan con la palabra reservada null.El resto de tablas contienen información adicional sobre los diferentes componentes usados

para construir un PC.

Clase PC

pcid | memoria | cpu | disco | tgrafica | precio

------+---------+---------+-----------+-----------+--------

1 | mem0001 | cpu0001 | disco0001 | ati001 | 1000

2 | mem0001 | cpu0001 | disco0002 | ati001 | 1100

3 | mem0002 | cpu0002 | disco0003 | nvidia001 | 1400

4 | mem0004 | cpu0003 | disco0004 | nvidia001 | 1600

5 | | cpu0001 | disco0001 | ati001 | 900

6 | | | | ati001 | 400

Clase CPU

cpu_id | cpu_fabricante | cpu_tipo

---------+----------------+------------

cpu0001 | intel | Core2 duo

cpu0002 | intel | Core2 Quad

cpu0003 | amd | Athlon X2

Clase Memoria

mem_id | mem_capacidad | mem_tipo

---------+---------------+------------

mem0001 | 1024 | DDR SDRAM

mem0002 | 1024 | DDR2 SDRAM




2/5

POO U2 Evaluación

Página 2 de 5

Clase Disco

disco_id | disco_fabricante | disco_capacidad

-----------+------------------+-----------------

disco0001 | seagate | 350



disco0004 | samsung | 500

Clase TarjetaGrafica

tgraf_id | tgraf_fabricante

-----------+------------------

ati001 | ati

nvidia001 | nvidia

Los objetos deberán almacenarse en los arreglos aPC[], aCPU[], aMemoria[], aDisco[] y

aTarjetaGrafica[]. Se adjunta el archivo “codigo de los arreglos de datos.txt” para que lo

incluya en su proyecto Java.

Utilizando estos arreglos de objetos resuelva con Java las siguientes consultas:

Consulta 1

Obtener una relación de solo los modelos de PC 'completos' a la venta. Queremos toda la

información disponible sobre los componentes que lo forman.

En esta consulta nos piden solamente, PCs completos, con todos sus componentes; es

decir, deberemos omitir aquellos que tengan al menos un valor null.

Cada PC tiene 4 componentes y la información de cada componente se encuentra en una

tabla separada. Lo que implica que para cada objeto PC que cumpla la condición de nonulidad en alguno de sus componentes, deberá recorrerse cada tabla asociada para

conseguir los datos de cada componente. Un PC solo tiene un componente de cada tipo.

Deberemos ordenar el arreglo PC[] en forma descendente por el atributo “precio”. Para ello

deberá implementarse la interface comparable y sobreescribir el método compareTo() en

la clase PC. Posteriormente usar el método Arrays.sort(aPC) para lograrlo (esto se hace una

sola vez). Se adjunta la carpeta “Ordenar un array de objetos por un atributo” con la

información suficiente para entender como hacerlo.

Utilice la instrucción System.out.format() para imprimir los resultados tal como se piden.

El resultado de nuestra consulta presentará las características de solo los PC completos:

pcid | mem_tipo | mem_mb | cpu_fab | cpu_tipo | disco_fab | disco_gb | tgraf_fab | precio

------+------------+--------+---------+------------+-----------+----------+-----------+--------

4 | DDR3 SDRAM | 2048 | amd | Athlon X2 | samsung | 500 | nvidia | 1600

3 | DDR2 SDRAM | 1024 | intel | Core2 Quad | seagate | 1024 | nvidia | 1400

2 | DDR SDRAM | 1024 | intel | Core2 duo | seagate | 500 | ati | 1100



3/5

POO U2 Evaluación

Página 3 de 5

Consulta 2

Obtener una relación de todos los modelos de PC a la venta. Queremos toda la información

disponible sobre los componentes que lo forman. Ordenar el resultado de mayor a menor

precio.

En esta consulta nos piden lo mismo que la consulta 1 pero de todos los modelos de PC, los

completos y los que se venden sin algún componente. La tabla PC es la tabla principal de

nuestra combinación y la tabla a la que le faltan valores en ciertos atributos en algunos

objetos.

Y el resultado de nuestra consulta presentará las características de todos los PC:


------+------------+--------+---------+------------+-----------+----------+-----------+--------


3 | DDR2 SDRAM | 1024 | intel | Core2 Quad | seagate | 1024 | nvidia | 1400



5 | | | intel | Core2 duo | seagate | 350 | ati | 900

6 | | | | | | | ati | 400

Nota importante:

¡Cuidado con el manejo de valores “null”!

Consulta 3

Obtener una relación de solo los modelos de 'PC NO completos' a la venta. Queremos toda

la información disponible sobre los componentes que lo forman

Si observan, esta consulta es similar a la Consulta 1, lo que la diferencía es la condición de

nulidad.

El resultado sería el esperado:


------+----------+--------+---------+-----------+-----------+----------+-----------+--------

5 | | | intel | Core2 duo | seagate | 350 | ati | 900

6 | | | | | | | ati | 400

De hecho, las tres consultas usan el mismo núcleo de búsqueda en las tablas asociadas, por

lo que programe el método consultar(PC) que es común y establezca la condición de

ejecución en el método main().


4/5

POO U2 Evaluación

Página 4 de 5

Consulta 4

Obtener una relación de todos los PC que tengan CPUs de AMD y discos de Samsung.

Queremos toda la información disponible sobre los componentes que lo forman.

Aquí deberá crear un método que reciba el objeto PC a revisar y los strings de las marcas

de cpu y disco a buscar. Recorra los arreglos aCPU y aD con las condiciones solicitadas y

utilice el método común consultar().

Y el resultado quedaría así:


------+------------+--------+---------+-----------+-----------+----------+-----------+--------


Consulta 5

Obtener una relación del número de PCs que tienen CPUs de Intel y de AMD. Ordenar de

mayor a menor.

Esta consulta es un poco diferente a las anteriores. Aquí tenemos que agrupar los

resultados según el fabricante de la CPU utilizada, y contar cuantos objetos existen en cada

grupo. Al necesitar solamente información contenida en la tabla 'CPU', solo tendremos que

combinar la tabla 'PC' con la tabla 'CPU'. Use un parámetro “elipsis” para pasar los nombres

de los fabricantes de cpus a contar. Se facilitará el código usando arreglos paralelos.

El resultado será:

cpu_fabricante | total

----------------+-------

intel | 4

amd | 1

Al final, espero que tengan una idea de cómo funciona el tema de combinar diferentes

tablas de objetos para obtener un resultado. En la vida real se encontrarán con ejemplos

bastantes complicados, lo importante es pensar la estrategia a seguir antes de empezar a

escribir la consulta Java. También es importante hacerlo paso a paso, aplicando las

restricciones necesarias hasta conseguir lo que queremos. Solamente la práctica los

ayudará a entender y escribir con soltura consultas complejas.


5/5

POO U2 Evaluación

Página 5 de 5

Que debo entregar

1.

Un archivo en formato zip conteniendo:

a.

Una cuartilla de texto describiendo el proceso para resolver cada paso delproblema. Esto incluye sentido común, creatividad y lógica matemática; así

como el proceso y las fuentes de investigación usados.

b. El proyecto en BlueJ identificado como “IS? ApPaterno InicApMaterno Nombre”.

El signo ? identifica el grupo en el que asiste.

Documents

01 Caso a Resolver