CASOS

PRÁCTICOS
PROGRAMACIÓN - B

DESARROLLO DE APLICACIONES WEB

 TEMA 6
Programación orientada a objetos
(POO). Fundamentos

Caso práctico 1
Para un programador es fundamental saber manejar las funciones
matemáticas, así como elaborar las ecuaciones utilizando los tipos
de variables más adecuados en cada caso. Imagina que necesitas
programar la ecuación para calcular el tiempo que ha permaneci-
do un objeto en caída libre. Por un lado, sabemos que el objeto ha
empezado su caída a una altura de 1450 metros y se ha detenido a
350 metros del suelo. Por otro lado, conocemos que la aceleración
de la gravedad es de 9,8 m/s2. Finalmente, sabemos que la fórmula
a aplicar es, en este caso, la siguiente:

Para resolver, pues, este problema, valora los siguientes aspectos:

1. Qué variables utilizarás, y de qué tipo.

2. Dónde declararás las variables.

3. Qué funciones matemáticas utilizarás.

Tras haber respondido a estas preguntas, codifica el programa en

Java.

Caso práctico 2
Modifica el programa anterior para que, en lugar de realizar un
solo cálculo con valores fijos, nos pregunte una altura inicial y cinco
valores de altura finales. Utiliza matrices para almacenar las alturas
finales y los cálculos resultantes en cada caso.

2 Casos prácticos
TEMA 7
Desarrollo de programas
organizados en clases

Caso práctico 1
Tomando como punto de partida el programa anterior, tenemos
ahora que comprobar que los valores introducidos no son negati-
vos (los objetos no pueden empezar su caída o caer a menos de
0 metros). En el caso de los valores de altura finales, tampoco es
posible que estos sean superiores a la altura inicial. Resuelve este
problema utilizando al menos un método.

Caso práctico 2
Toma el código resultante de la práctica anterior y realiza las si-
guientes actividades:

1. Mueve los métodos a una clase llamada Comprobaciones.

2. Modifica los métodos utilizando la técnica de la sobrecarga de

métodos.

Programación - B 3
 TEMA 8
Utilización avanzada de clases en el
diseño de aplicaciones

Caso práctico 1
Indica qué cambios realizarías en el código resultante de las prác-
ticas anteriores para aplicar el concepto de herencia de clases.

Caso práctico 2
Supongamos ahora que, además de asegurarnos de que la altura
a la que se detiene nuestro objeto no es negativa ni es mayor que
la altura de la que ha partido, queremos rechazar cualquier altura,
inicial o final, situada entre los 1000 y 2000 metros, ambos inclusi-
ve. Añade esta función de comprobación utilizando la herencia de
clases multinivel.

Caso práctico 3
El ejemplo anterior presupone que, a lo largo del código, nunca
estará permitido usar valores dentro del intervalo. Responde a la
pregunta “¿cómo flexibilizaríamos el código para realizar esta com-
probación fuera de las relaciones de herencia?” si no quisiéramos
que fuera ese el caso.

TEMA 9
Aplicación de estructuras de
almacenamiento en la programación
orientada a objetos

Caso práctico 1
En este ejercicio vamos a poner a prueba nuestra capacidad para
manejar matrices multidimensionales. En concreto, deberemos ma-
nejar los siguientes datos procedentes de un inventario informático:

4 Casos prácticos
 N.º de PC Conjuntos de componentes Tipo de componente

1 Procesador
Placa base
RAM
2
Tarjeta gráfica
Expansión
3 Capacidad SSD

Como vemos, cada matriz simple (es decir, cada columna) forma
una matriz bidimensional con la matriz adyacente: para cada PC in-
ventaríamos dos conjuntos de componentes, y para cada conjunto
dos tipos de componente.

La información para cada PC es la siguiente:

• PC 1: placa base A (procesador Intel, RAM 16 GB), expansión A

(GPU ATI, 1 TB).

• PC 2: placa base A (procesador Intel, RAM 16 GB), expansión B

(GPU NVIDIA, 512 GB).

• PC 3: placa base B (procesador AMD, RAM 32 GB), expansión A

(GPU ATI, 1 TB).

Declara e inicializa esta matriz tridimensional.

Caso práctico 2
Muestra en pantalla los valores de la matriz anterior.

Programación - B 5
 Caso práctico 3
Dispones de unos archivos procedentes de una base de datos de
libros donde figuran los títulos (tí[Link]) y los autores (autores.
txt) de todos los libros de una biblioteca. Has importado los datos
de los 10 primeros libros a sendas listas ArrayList. Los datos son los
siguientes:

• El juego de las maldiciones; Barker, Clive

• John muere al final; Wong, David
• Cujo; King, Stephen
• Los mitos de Cthulhu; Lovecraft, H.P.
• Carrie; King, Stephen
• La habitación de Naomí; Aycliffe, Jonathan
• Guerra mundial Z; Brooks, Max
• Esposa hechicera; Leiber, Fritz
• En la cripta; Lovecraft, H.P.

• A merced del viento; Highsmith, Patricia

A partir de estos datos, obtén una lista, ordenada alfabéticamente

y sin duplicados, de los autores listados.

TEMA 10
Control de excepciones

Caso práctico 1
Tomando como punto de partida el código resultante del ejercicio
anterior, añade una rutina para puntuar cada uno de los títulos del
1 al 10. Implementa la captura de excepciones para evitar que se
introduzcan números decimales o letras.

Caso práctico 2
Podemos simplificar el código del ejercicio anterior creando una
nueva excepción que maneje los números fuera del rango admiti-
do. Explica cómo lo harías.

6 Casos prácticos
TEMA 11
Lectura y escritura de información

Caso práctico 1
Para practicar la lectura y escritura de archivos, vamos a tomar
como punto de partida el programa [Link] de la actividad
anterior. Modifícalo para que la lista de los autores (listaAutores)
que presentamos al final se vuelque en un archivo de texto en lugar
de hacerlo en el terminal.

Caso práctico 2 [Link]/3PS56v4

En la siguiente práctica, vamos a leer los libros y los autores codi-
ficados de forma fija en [Link] desde un archivo de texto
llamado [Link], que puedes descargar desde este enlace.

TEMA 12
Interfaces gráficas de usuario

Caso práctico 1
Utiliza cualquier entorno de desarrollo que permita el trabajo con
la interfaz gráfica de Java, y diseña un JFrame para un formulario
similar al de la imagen.

Programación - B 7
 TEMAS 13 / 14 / 15

Caso práctico 1
Para resolver los ejercicios que te planteamos a continuación,
deberás tener una instalación de la base de datos Oracle configu-
rada en tu equipo. Una vez configurada apropiadamente, utiliza
la consulta siguiente para crear una tabla vacía llamada puntua-
ciones:

create table puntuaciones(id number(10),titulo

varchar2(40), autor varchar2(50), puntuacion
number(2));

A continuación, introduce manualmente los datos del archivo bi-

blioteca, dejando el campo puntuaciones en blanco.

Tu primer objetivo es obtener los datos de esta tabla para rellenar

las listas de títulos y autores en el programa [Link], pres-
cindiendo así del archivo de texto separado por comas. Para ello,
debes establecer una conexión con la base de datos, recuperar la
información de cada fila, y almacenarla en la lista apropiada.

Caso práctico 2
En esta última práctica, y partiendo de la práctica anterior, debes
almacenar las puntuaciones de los libros en la base de datos de
Oracle.

8 Casos prácticos
Programación - B 9
SOLUCIONARIO
TEMA 6
Programación orientada a objetos
(POO). Fundamentos

Solución del caso práctico 1

1. Los valores con los que vamos a trabajar son decimales, por lo
que utilizaremos variables de tipo float o double. Dado que las
variables de coma flotante solo se utilizan cuando es necesario
ahorrar espacio en memoria para manejar grandes matrices de
datos, y que no debemos utilizarlas cuando necesitamos calcular
valores con gran precisión, utilizaremos variables de tipo double.

2. De entre todas las variables que vamos a manejar, hay una que
nunca cambiará de valor, por lo que podemos definirla como
final. Además, dado que, potencialmente, tendremos que usarla
a lo largo del programa en diferentes métodos, sería preferible
declararla como variable de clase fuera del método principal.
El resto de las variables las declararíamos, en principio, como
variables locales dentro de main.

3. Además de las funciones matemáticas básica, tendremos que

utilizar la función [Link] para calcular la raíz cuadrada. Esta
función únicamente necesita, como parámetro un número o
variable de tipo double.

4. Teniendo en cuenta todo lo anterior, el programa quedaría

como sigue:

class TiempoCLibre {
final static double gravedad = 9.8;

public static void main (String [] args) {

double altInicial = 1450;
double altFinal = 350;
double tiempo = [Link]((-2 * (altFinal
- altInicial)) / gravedad);

[Link](“Un objeto que empieza

su caída libre en “ + altInicial + “ m y se detie-
ne a “
+ altFinal + “ m del suelo, permanece “ +
tiempo + “ segundos en el aire.”);;
}
}

Programación - B 11
 Solución del caso práctico 2
Lo primero que haremos es importar, al principio de nuestro có-
digo, la clase Scanner del paquete [Link], ya que la necesitamos
para poder introducir los diferentes valores desde la consola:

import [Link];

A continuación, debemos reemplazar la variable altFinal por una

matriz unidimensional con cinco valores, y crear otra matriz donde
iremos almacenando los resultados:

public static void main (String [] args) {

double[] altFinal = new double[5];
double[] tiempo = new double[5];

Seguidamente, creamos el objeto de Scanner y asignamos el valor

introducido a altInicial. Es importante recordar que esta variable
debe ser de tipo double, por lo que tendremos que usar el método
nextDouble():

Scanner entrada = new Scanner([Link]);

[Link](“Altura inicial en me-
tros:”);
double altInicial = [Link]();

A continuación, introducimos los cinco valores correspondientes

a la altura final (recuerda que las posiciones dentro de la matriz
empiezan en cero):

for (int i = 0; i < 5; ++i){

[Link](“Introduzca la altura
final nº “ + (i + 1) + “ en metros:”);
altFinal [i] = [Link]();
}

Finalmente, realizamos los cálculos y mostramos los resultados,

cerrando en objeto Scanner:

for (int i = 0; i < 5; ++i){

tiempo[i] = [Link]((-2 * (altFinal[i] -
altInicial)) / gravedad);
[Link](“El objeto “+ (i + 1) +
“ empieza su caída libre en “ + altInicial +
“ m y se detiene a “ + altFinal [i] + “ m

12 Solucionario
 del suelo, permaneciendo “ + tiempo[i]
+ “ segundos en el aire.”);
}
[Link]();

TEMA 7
Desarrollo de programas
organizados en clases

Solución del caso práctico 1

Como son varias las comprobaciones a realizar, vamos a crear dos
métodos que se ocupen de ellas. Empezaremos por el método que
comprueba que los valores no sean menores que cero:

public static double Negativos (double num) {

while (num < 0) {
[Link](“El valor no puede ser
menor que 0. Introduzca otro valor:”);
num = [Link]();
}
return num;
}

Dado que estamos usando aquí el objeto de Scanner, tenemos que

sacarlo fuera del método principal para poder utilizarlo:

static Scanner entrada = new Scanner([Link]);

final static double gravedad = 9.8;

Para llamar al método Negativos, modificamos la declaración de la

variable altInicial de la siguiente forma:

double altInicial = Negativos([Link]-

ble());

Usaremos el mismo método para comprobar los valores de altura

finales:

altFinal [i] = Negativos([Link]());

Programación - B 13
 A continuación, escribimos el método que comprueba que los valo-
res finales no sean mayores que la altura inicial:

public static double AlturaInicial (double num,

double altura) {
while (num > altura) {
[Link](“El valor no puede ser
mayor que “ + altura + “ metros. Introduzca otro
valor:”);
num = Negativos([Link]());
}
return num;
}

Fíjate en que también debemos llamar al método de comprobación

de negativos dentro de este nuevo método cada vez que se nos
pide que tecleemos un nuevo valor.

Finalmente, modificamos el bucle en el que introducimos los datos

de la siguiente forma:

for (int i = 0; i < 5; ++i){

[Link](“Introduzca la altura final
nº “ + (i + 1) + “ en metros:”);
altFinal [i] = AlturaInicial(Negativos(entra-
[Link]/3chXkgj [Link]()), altInicial);
}

En el archivo de este enlace encontrarás el código completo.

Solución del caso práctico 2

1. Los métodos sobrecargados podrían quedar como sigue:

double Comprobar(double num)

double Comprobar(double num, double altura)

Cuando se pasa un solo parámetro, invocamos el método que

comprueba si el número es negativo, mientras que, si pasamos
también el parámetro de la altura, se comprueba si esta excede
de la altura máxima.

2. Al mover los métodos a una clase, es necesario actualizar tam-

bién todas las referencias del código:

14 Solucionario
 import [Link];

class Comprobaciones {
public static double Comprobar(double num) {
while (num < 0) {
[Link](“El valor no puede ser menor que 0. Introduzca
otro valor:”);
num = [Link]();
}
return num;
}

public static double Comprobar(double num, double altura) {

while (num > altura) {
[Link](“El valor no puede ser mayor que “ + altura +
“ metros. Introduzca otro valor:”);
num = Comprobar([Link]());
}
return num;
}
}

class Programa {
public final static double gravedad = 9.8;
public static Scanner entrada=new Scanner([Link]);

public static void main (String [] args) {

double[] altFinal = new double[5];
double[] tiempo = new double[5];

[Link](“Altura inicial en metros:”);

double altInicial = [Link]([Link]());

for (int i = 0; i < 5; ++i){

[Link](“Introduzca la altura final nº “ + (i + 1) + “
en metros:”);
altFinal [i] = [Link]([Link]-
bar([Link]()), altInicial);
}

for (int i = 0; i < 5; ++i){

tiempo[i] = [Link]((-2 * (altFinal[i] - altInicial)) / grave-
dad);
[Link](“El objeto “+ (i + 1) + “ empieza su caída li-
bre en “ + altInicial + “ m y se detiene a “
+ altFinal [i] + “ m del suelo, permaneciendo “ + tiempo[i] + “
segundos en el aire.”);
}
[Link]();
}
}

[Link]/3Ap6a3N

En el archivo que encontrarás en este enlace puedes ver el código.

Programación - B 15
 TEMA 8
Utilización avanzada de clases en el
diseño de aplicaciones

Solución del caso práctico 1

Podemos reubicar los dos métodos de la clase Comprobaciones
en una superclase llamada Negativos y una subclase denominada
MaxAltura:

class Negativos {
public double neg(double num) {
while (num < 0) {
[Link](“El valor no puede
ser menor que 0. Introduzca otro valor:”);
num = [Link]();
}
return num;
}
}

class MaxAltura extends Negativos {

public double alt(double num, double altura) {
while (num > altura) {
[Link](“El valor no pue-
de ser mayor que “ + altura + “ metros. Introduzca
otro valor:”);
num = neg([Link]-
ble());
}
return num;
}
}

Observa que, en el método alt de la clase MaxAltura, cuando com-

probamos si el número reintroducido es negativo, no es necesario
hacer referencia explícita a la clase Negativos, ya que el método
neg que se utiliza aquí viene heredado de la superclase. Nótese de
igual manera que, dado que vamos a requerir de un constructor
para llamar a las funciones (y, como sabemos, los constructores no
pueden ser estáticos), los métodos tampoco pueden establecerse
como tales.

16 Solucionario
A continuación, realizaremos los cambios en las llamadas del blo-
que principal. Primero creamos el nuevo constructor a partir de la
subclase MaxAltura:

MaxAltura comprobar = new MaxAltura();

A partir de ahora, cada vez que queramos comprobar si un número

es negativo, llamaremos a la función neg utilizando el constructor
que acabamos de crear:

[Link](“Altura inicial en metros:”);

double altInicial = [Link]([Link]-
ble());

Lo vemos también en la comprobación de la altura máxima, en la

que llamamos a la función [Link], donde debemos asegu-
rarnos de que el número que le pasamos a la función, en primera
instancia, no sea negativo (dentro de la propia función se volverá
a comprobar este extremo cada vez que el usuario introduzca un
valor no admitido):

for (int i = 0; i < 5; ++i){

[Link](“Introduzca la altura final
nº “ + (i + 1) + “ en metros:”);
altFinal [i] = [Link]([Link](en-
[Link]()), altInicial);
} [Link]/3pSbXKv

Si revisas el archivo [Link] que te proporcionamos

en este enlace, verás que el código es mucho más legible que
el anterior, donde ubicábamos los dos métodos dentro de una
misma clase.

Solución del caso práctico 2

Para resolver este caso tenemos que crear otra subclase que con-
tenga el método para comprobar que el número proporcionado
no esté dentro del intervalo especificado, pero debemos tener en
cuenta que el orden de las herencias es importante. De esta forma,
crearemos una clase llamada IntervaloAltura que sea una subclase
de Negativos, y haremos que la clase MaxAltura sea la que extienda
ahora esta nueva clase:

Programación - B 17
 class Negativos {
public double neg(double num) {
while (num < 0) {
[Link](“El valor no puede
ser menor que 0. Introduzca otro valor:”);
num = [Link]();
}
return num;
}
}

class IntervaloAltura extends Negativos {

public double inter(double num) {
while (num > 999 && num < 2001) {
[Link](“La altura no pue-
de estar entre 1000 y 2000 metros. Introduzca otro
valor:”);
num = neg([Link]-
ble());
}
return num;
}
}

class MaxAltura extends IntervaloAltura {

public double alt(double num, double altura) {
while (num > altura) {
[Link](“El valor no pue-
de ser mayor que “ + altura + “ metros. Introduzca
otro valor:”);
num = inter(neg([Link]-
Double()));
}
return num;
}
}

Como vemos, la función neg solo evalúa si un número es negativo;

la función inter, si es negativo (usando neg) y si está entre el inter-
valo especificado; y la función alt, si el valor es negativo (usando
neg), si está en el intervalo (usando inter), y si es superior a la altura
máxima permitida.

Así, cuando solicitamos la altura máxima, podemos comprobar

fácilmente que el número asignado no sea negativo y que no esté
dentro del intervalo especificado:

18 Solucionario
 [Link](“Altura inicial en metros:”);
double altInicial = [Link]([Link]-
g([Link]()));

Y, a la hora de introducir la altura final, podemos realizar con la

misma facilidad las tres comprobaciones necesarias:

for (int i = 0; i < 5; ++i){

[Link](“Introduzca la altura final
nº “ + (i + 1) + “ en metros:”);
altFinal [i] = [Link](([Link]-
ter([Link]([Link]()))), altIni-
[Link]/3CvZlAd
cial);
}

Puedes consultar el código en este enlace.

Solución del caso práctico 3

En este caso, nuestra solución es usar la técnica de agregación. Así,
en primer lugar, reprogramamos la clase IntervaloAltura para que
quede de la siguiente forma:

class IntervaloAltura {
public static double inter(double num, Double
altura) {
Negativos negat = new Negativos();
MaxAltura maxalt = new MaxAltura();

while (num > 999 && num < 2001) {

[Link](“La altura no pue-
de estar entre 1000 y 2000 metros. Introduzca otro
valor:”);
if (altura == null) {
num = [Link]([Link].
nextDouble());
}
else {
num = [Link]([Link](Progra-
[Link]()), altura);
}
}
return num;
}
}

Programación - B 19
 Fíjate que, al no tratarse ya de una extensión de negativos, no po-
demos utilizar el método neg directamente. Tampoco es posible
referenciarlo de forma estática, al no estar declarado como tal,
pero sí podemos agregarlo utilizando un constructor, en este caso,
Negativos(). Y lo mismo sucede con el cálculo de la altura máxima,
para lo cual usaremos el constructor MaxAltura().

Por otra parte, si la variable AltInicial se ha inicializado, debemos

comprobar que el valor introducido, además de no estar dentro del
intervalo, no excede dicho valor. Si todavía no hemos introducido
la altura inicial, el parámetro altura tomará valor nulo (lo cual nos
obliga a utilizar Double en lugar de double), y no se utiliza la fun-
ción alt; en caso contrario, significa que ya hemos introducido una
altura máxima, por lo que someteremos el valor a comprobación
usando maxalt.

En cuanto a la clase MaxAltura, ahora vuelve a ser una subclase de

Negativos:

class MaxAltura extends Negativos {

public double alt(double num, double altura) {
while (num > altura) {
[Link](“El valor no pue-
de ser mayor que “ + altura + “ metros. Introduzca
otro valor:”);
num = neg([Link]-
ble());
}
return num;
}
}

Dado que hemos creado el método inter como estático (public

static double inter(double num)), no necesitamos en esta clase
ningún constructor, ya que podemos referenciarlo de manera es-
tática ([Link]). En consecuencia, podemos llamar a
este método de esta forma cada vez que sea necesario comprobar
el intervalo:

[Link](“Altura inicial en metros:”);

double altInicial = [Link](compro-
[Link]([Link]()), null);

20 Solucionario
 for (int i = 0; i < 5; ++i){
[Link](“Introduzca la altura final
nº “ + (i + 1) + “ en metros:”);
altFinal [i] = [Link](compro-
[Link](([Link]([Link]())), al-
tInicial), altInicial);
}

No importa si tu solución es diferente a la aquí presentada. Lo

importante es que, además de seguir las instrucciones básicas
que se han proporcionado, hayas tenido en cuenta reusabilidad
del código. Te recomendamos que dediques un tiempo a intentar
mejorar la eficiencia del programa, cuyo código encontrarás en el
archivo [Link], y a incorporar mecanismos de control
de errores (por ejemplo, cuando los valores introducidos son alfa-
numéricos).

Programación - B 21
 TEMA 9
Aplicación de estructuras de
almacenamiento en la programación
orientada a objetos

Solución del caso práctico 1

En primer lugar, reservamos en memoria la matriz, a la que lla-
maremos inventario. En ella almacenaremos la información de 3
máquinas, 2 conjuntos de componentes y 2 tipos de componentes
por cada conjunto:

public class Matrices {

public static void main (String [] args) {
String [][][] inventario = new String [3]
[2][2];
}
}

A continuación, introducimos los valores proporcionados en la

matriz:

inventario[0][0][0] = “Intel”;
inventario[0][0][1] = “16 GB”;
inventario[0][1][0] = “ATI”;
inventario[0][1][1] = “1 TB”;

inventario[1][0][0] = “Intel”;
inventario[1][0][1] = “16 GB”;
inventario[1][1][0] = “NVIDIA”;
inventario[1][1][1] = “512 GB”;

inventario[2][0][0] = “AMD”;
inventario[2][0][1] = “32 GB”;
inventario[2][1][0] = “ATI”;
inventario[2][1][1] = “1 TB”;

También podríamos haberlo hecho de una forma más simple:

String[][][] inventario = {
{ { “Intel”,”16 GB”}, {“ATI”,”1 TB”}
},
{ { “Intel”,”16 GB” }, { “NVIDIA”,
“512 GB” } },
{ { “AMD”,”32 GB” }, { “ATI”, “1 TB” }
}
};

22 Solucionario
Solución del caso práctico 2
Para recorrer todos los valores de una matriz tridimensional, nece-
sitaremos anidar tres bucles de la siguiente manera:

for(int pc = 0; pc < [Link]; pc++){

[Link](“PC nº “+ (pc + 1));

for (int conjunto = 0; conjunto < inventa-

rio[pc].length; conjunto++){

if (conjunto == 0)
[Link](“Placa base”);
else
[Link](“Expansión”);

[Link](“Componentes:”);

for (int componentes = 0; componentes <

inventario[pc][conjunto].length; componentes++){

[Link](inventario[pc][con-
junto][componentes]+”\t”);
}
[Link]();
}
[Link]();
}

El primero de los bucles recorre todas las posiciones de la primera [Link]/3ANth9C

dimensión de la matriz (los PC), el segundo todos los conjuntos
(placa base y expansión), y el tercero, todos los componentes.

Dispones del código final en este enlace.

Programación - B 23
 Solución del caso práctico 3
La forma más sencilla de obtener una lista ordenada alfabética-
mente y sin duplicados es utilizando TreeSet. Partimos del siguiente
código en el que las listas ya están inicializadas:

import [Link];
import [Link];

public class Biblioteca {

public static void main(String[] args){
ArrayList <String>titulos = new ArrayList<S-
tring>();
[Link](“El juego de las maldiciones”);
[Link](“John muere al final”);
[Link](“Cujo”);
[Link](“Los mitos de Cthulhu”);
[Link](“Carrie”);
[Link](“La habitación de Naomí”);
[Link](“Guerra mundial Z”);
[Link](“Esposa hechicera”);
[Link](“En la cripta”);
[Link](“A merced del viento”);

ArrayList<String> autores = new ArrayList<S-

tring>();
[Link](“Barker, Clive”);
[Link](“Wong, David”);
[Link](“King, Stephen”);
[Link](“Lovecraft, H.P”);
[Link](“King, Stephen”);
[Link](“Aycliffe, Jonathan”);
[Link](“Brooks, Max”);
[Link](“Leiber, Fritz”);
[Link](“Lovecraft, H.P”);
[Link](“Highsmith, Patricia”);

A continuación, recorremos la lista de autores ([Link]()) y

vamos colocando cada valor en un TreeSet llamado listaAutores:

TreeSet <String>listaAutores = new TreeSe-

t<String>();

for (int pos = 0; pos < [Link]();

pos++) {
[Link]([Link](pos));
}

24 Solucionario
Por último, presentamos el listado por el terminal usando un bucle
de tipo for each:

for (String autor : listaAutores) {

[Link](autor);
}
}
}

TEMA 10
Control de excepciones

Solución del caso práctico 1

Empezaremos codificando la rutina de introducción de puntuacio-
nes, en la que controlamos que el número esté dentro del rango
establecido. Lo primero es importar las bibliotecas [Link]
y [Link], y crear una clase con nuestra
rutina de comprobación de rango:

import [Link];
import [Link];
import [Link];
import [Link];

class Rango {
public static int r(int num, String titulo) {
while ( num < 1 || num >10) {
[Link](“¡Valor fuera de
rango!”);
[Link](titulo + “: “);
num = [Link]();
}
return num;
}
}

Luego creamos el objeto Scanner:

public class Biblioteca {

public static Scanner entrada = new Scan-
ner([Link]);

Programación - B 25
 A continuación, declaramos una nueva lista de enteros, llamada
puntuaciones, y la rutina de entrada de datos:

ArrayList <Integer>puntuaciones = new ArrayList

<Integer>();

[Link](“VALORE LOS LIBROS DEL 1 AL 10

\n=============================”);

for (int pos = 1; pos < [Link](); pos++){

[Link]([Link](pos) + “: “);
int num = Rango.r([Link](), titulos.
get(pos));
[Link](num);
[Link]();
}

La rutina funciona correctamente, hasta que intentamos intro-

ducir un valor no válido, como una letra o un número decimal.
Esto arroja la excepción “Exception in thread “main” [Link].
InputMismatchException”, motivo por el que habíamos incluido la
biblioteca InputMismatchException. Para implementarla, cambia-
remos el bucle for por while, e incluiremos try-catch para manejar
los errores de tipo de entrada incorrecto:

int pos = 0;
while (pos < [Link]()) {
try {
[Link]([Link](pos) + “: “);
int num = Rango.r([Link](), titu-
[Link](pos));
[Link](num);
[Link]();
pos++;
} catch (InputMismatchException ex) {
[Link](“¡No introduzca letras
o decimales!”);
[Link]();
}
}
[Link]/3Khs3H3
Como ves, es necesario vaciar entrada con nextLine() si no quere-
mos que se nos muestre el mensaje de error en bucle. El código
completo lo encontrarás en este enlace.

26 Solucionario
Solución del caso práctico 2
Primero es necesario transformar clase Rango en una excepción:

class Rango extends Exception {

}

A continuación, modificamos el bucle while de la manera siguiente:

int pos = 0;
while (pos < [Link]()) {
try {
[Link]([Link](pos) + “: “);
int num = [Link]();
if (num < 1 || num > 10) throw new Ran-
go();
[Link](num);
[Link]();
pos++;
}
catch (InputMismatchException ex) {
[Link](“¡No introduzca letras
o decimales!”);
[Link]();
}
catch (Rango ex) {
[Link](“¡Valor fuera de ran-
go!”);
[Link]();
}
}
[Link]/3wuc0Qt
Como podemos observar, si el número introducido está fuera del
rango, arrojamos la excepción Rango(). Revisa el código en el ar-
chivo de este enlace.

Programación - B 27
 TEMA 11
Lectura y escritura de información

Solución del caso práctico 1

En primer lugar, se importan las bibliotecas necesarias para abrir y
escribir archivos:

import [Link];
import [Link];

A continuación, en el bloque principal, creamos el archivo en la ruta

D:\[Link]:

File archivoAutores = new File(“D:/archivoAutores.

txt”);
[Link]();

Fíjate en que las rutas deben utilizar las barras normales como se-
paradores, ya que la contrabarra se usa como carácter de escape.
Recuerda que estas acciones sobre ficheros son susceptibles de
generar excepciones, por lo que tendrás que utilizar try-catch.

Seguidamente, creamos el objeto escribeArchivo, y lo utilizamos

para escribir cada autor en el archivo de forma secuencial. Termi-
nada la operación, cerramos el archivo:

FileWriter escribeArchivo = new FileWriter(“D:/ar-

[Link]”);
for (var autor : listaAutores) {
[Link](autor);
}
[Link]();

Si abrimos el archivo recién creado, veremos que el resultado final

no es el esperado:

Aycliffe, JonathanBarker, CliveBrooks, MaxHighsmi-

th, PatriciaKing, StephenLeiber, FritzLovecraft,
[Link], David

Esto es así porque FileWriter no implementa métodos para for-

matear el texto, por lo que, en nuestro caso, es preferible usar

28 Solucionario
PrintWriter (ten en cuenta que debes también reemplazar java.
[Link] por [Link]):

PrintWriter escribeArchivo = new Prin-

tWriter(“D:/[Link]”);
for (var autor : listaAutores) {
[Link](autor);
}
[Link]();

En este caso, utilizamos println() para escribir cada entrada de

texto en una nueva línea.

Ahora podemos implementar las medidas de control de errores:

try {
File archivoAutores = new File(“D:/archivoAu-
[Link]”);
[Link]();

PrintWriter escribeArchivo = new PrintWri-

ter(“D:/[Link]”);
for (var autor : listaAutores) {
[Link](autor);
if ([Link]() == true)
[Link](“Se produjo un
error al escribir en el archivo.”);
}
[Link]();
}
catch (IOException ex) {
[Link](“Se ha producido un
error.”);
[Link]();
}

Lo que hemos hecho es, por un lado, utilizar IOException para captu-
rar cualquier error que se produzca durante la creación del archivo,
y por otro, el método checkError() de PrintWriter para comprobar [Link]/3cneaum
si se producen errores de escritura, en cuyo caso escribeArchivo.
checkError() adoptará el valor true. Puedes ver el código final en el
archivo de este enlace.

Programación - B 29
 Solución del caso práctico 2
Lo primero que debes hacer es crear la rutina que nos permita leer
nuestro archivo de texto. Una posibilidad es utilizar, para ello, Fi-
leInputStream. Examinemos el siguiente código:

File biblioteca = new File(“D:/[Link]”);

if (![Link]()){
[Link]();
[Link](“El archivo “ + biblioteca
+ “ no existe.\nSe ha creado uno vacío.”);
}
Scanner leeArchivo = new Scanner(new FileInputS-
tream(biblioteca), “UTF-8”);

ArrayList<String> datos = new ArrayList<String>();

while ([Link]()) {
String[] texto = [Link]().
split(“[;]”, 0);
for(String mitexto : texto) {
[Link](mitexto);
}
}

FileInputStream() necesita una referencia al archivo (en nuestro

caso, biblioteca, que almacena su ruta completa), pero dicho archi-
vo debe existir. Por lo tanto, lo que hacemos es comprobar si es así,
y, en caso contrario, lo creamos mediante el método createNewFi-
le(), mostrando un mensaje que nos advierte de la operación y de
que el archivo creado estará vacío.

A continuación, usamos el método hasNetxLine() para ir leyendo

el archivo, línea por línea, hasta llegar al final. Cada línea se divide
utilizando el carácter punto y coma, y se va almacenando en una
lista llamada datos.

No obstante, para ejecutarse este bloque necesita estar dentro de

un bloque try-catch, por lo que tendremos que modificarlo de la
siguiente manera:

ArrayList<String> datos = new ArrayList<String>();

ArrayList<String> titulos = new ArrayList<S-
tring>();
ArrayList<String> autores = new ArrayList<S-
tring>();
ArrayList <Integer>puntuaciones = new ArrayList

30 Solucionario
 <Integer>();

try{
File biblioteca = new File(“D:/Biblioteca.
txt”);
if (![Link]()){
[Link]();
[Link](“El archivo “ + biblio-
teca + “ no existe.\nSe ha creado uno vacío.”);
}
Scanner leeArchivo = new Scanner(new Fi-
leInputStream(biblioteca), “UTF-8”);

while ([Link]()) {
String[] texto = [Link]().
split(“[;]”, 0);
for(String mitexto : texto) {
[Link](mitexto);
}
}
}
catch (IOException ex) {
[Link](“Se ha producido un
error.”);
[Link]();
}

Observa que, además de añadir el control de errores, tenemos que

sacar la declaración de la lista datos fuera del bloque try-catch, ya
que la utilizamos más adelante. Para que nuestro código quede
más organizado, hemos movido también a esta parte la declara-
ción de las listas de autores, títulos y puntuaciones que se utilizarán
más adelante.

Lo siguiente es trasladar los datos a las dos listas que vamos a ma-
nejar en adelante, la de títulos y la de autores. Para ello recorremos
la lista datos y vamos almacenando cada una de sus posiciones en
una y otra lista, de forma alternativa:

int pos = 0;
while (pos < [Link]()){
[Link]([Link](pos));
pos++;
[Link]([Link](pos));
pos++;
}

Programación - B 31
 Para finalizar, mostramos los datos de ambas listas en el terminal:

for (pos = 0; pos < [Link](); pos++) {

[Link]([Link](pos) + “; “ +
[Link](pos));
[Link]/3ANzi6z }

Como siempre, dispones del código final en el archivo de este

enlace.

TEMA 12
[Link]/3TjbT3O
Interfaces gráficas de usuario

Solución del caso práctico 1

Dependiendo del entorno que hayas escogido, así como de los
campos y controles que hayas implementado, el código resultan-
te será distinto. No obstante, te proporcionamos tres archivos de
ejemplo por si necesitas utilizarlos como referencia.
[Link]/3CuPSsY
Enlace 1

Enlace 2

TEMA 13 / 14 / 15

Solución del caso práctico 1

En primer lugar, vamos a crear un bloque try-catch que gestione la
conexión con la base de datos. Recuerda que, para que el programa
funciones, debes haber indicado la ruta a la biblioteca referenciada
[Link] u [Link], dependiendo de tu versión de Java. También
es necesario importar las bibliotecas [Link]:

import [Link].*;
import [Link].*;

32 Solucionario
 class Rango extends Exception {}

public class Biblioteca {

public static Scanner entrada = new Scan-
ner([Link]);

public static void main(String[] args){

ArrayList<String> titulos = new ArrayLis-
t<String>();
ArrayList<String> autores = new ArrayLis-
t<String>();

try {
[Link](“[Link]-
cleDriver”);
Connection conec = [Link]-
Connection(
“jdbc:oracle:thin:@localhos-
t:1521:xe”, “sys as SYSDBA”, “contraseña”);
Statement stat = [Link]-
ment();

Como ves, hemos creado un objeto de conexión llamado conec

usando el método getConnection(), con los parámetros de nuestra
conexión. En tu caso, deberás reemplazar el nombre de usuario (sys
as SYSDBA) y la contraseña. A continuación, creamos el objeto stat
que nos servirá para realizar las consultas. Ahora ya estamos listos
para leer los datos de la tabla:

ResultSet resul = [Link](“select * from

puntuaciones”);
while ([Link]())
[Link]([Link](1) +
“ “ + [Link](2) + “; “ + [Link]-
tring(3));

Esta rutina crea un objeto llamado resul donde se van almacenan-

do, línea por línea, los registros de la tabla. Con el método next(),
recorremos los tres primeros campos (identificador, título y autor)
y los volcamos en la consola. Con esto, resulta sencillo adaptar el
código para que dichos datos se almacenen directamente en las
listas de títulos y autores:

ResultSet resul = [Link](“select * from

puntuaciones”);
while ([Link]()) {
[Link]([Link](2));
[Link]([Link](3));
}

Programación - B 33
 Finalmente, mostramos el contenido de las listas:

for (int pos = 0; pos < [Link](); pos++) {

[Link]([Link](pos) + “; “ +
[Link](pos));
}
}

Todavía no cerramos la conexión con la base de datos, puesto que

la vamos a necesitar en el ejercicio siguiente. No te olvides de aña-
dir el correspondiente catch al final del programa:

catch (Exception e) {
[Link](e);
}

Solución del caso práctico 2

En el código del que partimos, ya tenemos programado el bloque
donde se pregunta la valoración de cada libro y se almacenan en
una lista llamada puntuaciones. En este caso, en lugar de dicha lista
usaremos la columna de puntuaciones de la base de datos:

int pos = 0;
while (pos < [Link]()) {
[Link]([Link](pos) + “: “);
int num = [Link]();
if (num < 1 || num > 10) throw new Rango();
[Link](“update puntuaciones set
puntuacion = ‘” + num + “’ where id = ‘” + (pos +
1) +”’”);
pos++;
}
[Link]();

[Link]/3Q48Z0l El método executeUpdate() es, en este caso, el encargado de ac-

tualizar los valores de la columna de puntuaciones en la base de
datos. Cuando finaliza el proceso, cerramos la conexión.

Dispones del código del programa en el archivo de este enlace.

34 Solucionario
Programación - B 35
CASOS
PRÁCTICOS

PROGRAMACIÓN - B

DESARROLLO DE
APLICACIONES WEB

Centro integral de
formación profesional