EJERCICIOS

PARCIAL JAVA
Olivia Gallego Toscano
Tema 1:
Ej1: contador de segundos de una fecha dada………………………p.1
Ej2: max de int, char, short………………………………………….p.2
Ej3: array múltiplos de 5 y suma de ellos…………………………..p.2
Ej4: max y min de una lista…………………………………………p.3
Ej5: tablas de multiplicar……………………………………………p.5
Ej6: N primeros nº primos de una lista………………………………p.6
Ej7: descomponer nº en factores primos……………………………..p.7
Ej8: media, max, min, de un array de nº……………………………..p.8-9
Ej9: vectores y producto escalar……………………………………..p.10-11
Ej10: matriz cuadrada con nº aleatorios……………………………..p.12
Ej11: multiplicar matrices……………………………………………p.13-14
Ej12: contar vocales de en una cadena de caracteres………………..p.15
Ej13: escribir al revés una cadena de caracteres…………………….p.16
Ej14: palindroma……………………………………………………p.17

Tema 3:
Ej1: vector de 3 dimensiones……………………………………….p.18
Ej2: fecha…………………………………………………………p.19-21
Ej3: calculadora de nºracionales………………………………….p.22-24
Ej4: calculadora de nºimaginarios………………………………..p.25-26
Ej5: Persona: IMC, mayor de edad, generarDNI aleatorio, Boolean de
tipo de peso…………………………………………………..p.27-31
Ej6: Password: crear aleatoriamente en un array y decir si es fuerte…p.32-34
Ej10: salario trabajadores empresa…………………………………p.35-37
Ej11: cuentas bancarias…………………………………………….p.38-47
Ej12: fecha con excepciones……………………………………….p.48-50
Ej13: algoritmo de Newton-Raphson………………………………p.51-52
Tema 4:
Ej1: escribir caracteres y almacenar en fichero de texto………..p.53
Ej2: ej1 y mostrar contenido de un archivo…………………….p.54-55
Ej3: comprobar si dos archivos son iguales…………………….p.56-57
Ej4: contar número de palabras de un archivo

Tipo Test:
Tipo Test…………………………………………………………..p.63-65
Explica brevemente el método de búsqueda binaria ¿que prerequisites debe
cumplir?…………………………………………………………..p.66

Ejemplos Tipo:
Ej1: control de ventas de una tienda………………………………p.67-69
Ej2: figuras geométricas…………………………………………..p.70-74
Ej3: control de préstamos de una biblioteca………………………p.75-83
Ej4: empresa, empleados, jefe…………………………………….p.84-89
Ej5: lista de nº enteros…………………………………………….p.90-92
Ej6: representación de árbol binario y búsqueda enteros…………p.93-96
Ej7: MyArrayList que simule el arrayList de Java………………..p.97-100
Ej8: Ordenar array con el algoritmo “Bubble Sort”………………p.101
Ej9: juego de cartas……………………………………………….p.102-103
Ej10: socios de una sociedad……………………………………..p.104-108
Ej11: compra online………………………………………………p.109-125

Ejercicios Prácticos:
Ej1: transformar bucles…………………………………………..p.126
Ej2: UML sociedad………………………………………………p.127-128
Ej4: Preguntas clase test de código de figuras geométricas……..p.129-130
Ej5: ejercicio Metabolitos……………………………………….p.131-138
EJERCICIOS
TEMA 1
 1. Escribir un programa que defina variables que representen el número de días de un
año, el número de horas que tiene un día, el número de minutos que tiene una hora y
el número de segundos que tiene un minuto. Emplear las variables que ocupen el
mínimo espacio de memoria posible. A continuación, calcular el número de segundos
que tiene un año y almacenar el valor del cálculo en otra variable. Realizar
preferiblemente mediante una función que reciba como parámetros el número de
años, meses y días y devuelva el número de segundos de los días, meses y años
introducidos.
package org.example;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Ej1 {

public static void fecha(int anios, int meses, int dias) {

int seg_anios= anios*360*24*60*60;
int seg_meses= meses*30*24*60*60;
int seg_dias= dias*24*60*60;
int total= seg_anios+seg_dias+seg_meses;
System.out.println("Los segundos de "+anios+ " anios:
"+seg_anios);
System.out.println("Los segundos de "+meses+ " meses:
"+seg_meses);
System.out.println("Los segundos de "+dias+ " dias:
"+seg_dias);
System.out.println("El total de segundos es: "+total);
}

public static void main(String[] args) {

try{
int anios;
int meses;
int dias;
BufferedReader consola= new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Dame el nº de anios:");
anios= Integer.parseInt(consola.readLine());
System.out.println("Dame el nº de meses: ");
meses= Integer.parseInt(consola.readLine());
System.out.println("Dame el nº de dias: " );
dias= Integer.parseInt(consola.readLine());
fecha(anios, meses, dias);
}catch (IOException e){
System.out.println(e.getMessage());
}

1
 2. Escribir un programa que muestre por consola los mayores números enteros que se
pueden representar mediante un char, short e int.

package org.example;

import static java.lang.Character.*;

public class Ej2 {

public static void main(String[]args){
System.out.println("Max int= "+ Integer.MAX_VALUE);
System.out.println("Max char= "+ Character.MAX_VALUE);
System.out.println("MAx short= "+(short) Short.MAX_VALUE);
}
}

3. Calcular la suma de todos los múltiplos de 5 comprendidos entre 1 y 100. Calcular

además cuantos hay (ver operaciones sobre arrays) y visualizar cada uno de ellos.
Utilizar una función que reciba el número de múltiplos de 5 y devuelva un array
conteniedo todos los múltiplos de 5 desde el valor del parámetro begin hasta el valor
del parámetro end. Realizar otra función que dado un array como parámetro, lo
recorra de inicio a fin y devuelva la suma de todos sus valores.

package org.example;

public class Ej3 {

//creamos un main que sirva como interfaz para simplificar el codigo:
public static void main(String[] args) {
//delimitamos el rango de busqueda de los multiplos
int begin = 1;
int end = 100;
//llamamos a la funcion de busqueda de multiplos
int []multiples= multiples(begin, end);
//pasamos por cada posicion del array para mostrar el multiplo guardado en cada casilla
for(int i=begin; i<=end; i++ ){
System.out.println("Multiple de 5: " + multiples[i]);
}
//llamamos a la funcion suma
int suma=suma(multiples);
//imprimimos todo el contenido de la suma
System.out.println("La suma de los multiples de 5 de 1 a 100 es: "+suma);
}

2
 public static int[] multiples(int begin, int end) {//creamos un afuncion para buscar los
multiplos y
// simplificar el codigo
//inicializamos un contador a 0
int count=0;
//contamos todos los multiplos que hay de 1 a 100
for(int i=begin; i <= end; i++){
if(i % 5 == 0){
count++;
}
}
//reservamos memoria para el numero justo de multiplos
int []multiple=new int[count];
//creamos una variable que nos va a permitir recorrer las posiciones del array
int j=0;
//recorremos el array para asignarle una posicion a cada multiplo
for (int i=begin; i <= end; i++) {
if (i % 5 == 0) {
multiple[j]=i;
j++;//avanzamos de una posicion en el array
}
}
//devolvemos a la funcion main el contenido de nuestro array
return multiple;
}
public static int suma(int []multiple){// funcion para realizar la suma de los multiplos
//inicializamos la suma a 0
int suma=0;
//realizamos la suma de cada uno de los vamores del array
for (int j : multiple) { //añadir multiple de 5 a la suma general
suma += j;
}
//devolver la suma total a la funcion
return suma;
}
}

3
 4. Escribe un programa que calcule el mínimo y el máximo de una lista de números
enteros positivos introducidos por el usuario. La lista finalizará cuando se introduzca un
número negativo.

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class tema1 {

public static void main(String[] args) {
int []lista=new int[300];
int max=Integer.MIN_VALUE; //estan alternados!!
int min=Integer.MAX_VALUE;
int contador=0;
int i=0;
try{
do{
BufferedReader teclado= new BufferedReader(new InputStreamReader(System.in));
System.out.println("Dame un numero (negativo para finalizar lal lista): ");
i= Integer.parseInt(teclado.readLine());
lista[contador]=i;
contador++;
}while(i>0);
for (int j=0; j<contador; j++){
System.out.println("Tu lista: "+ lista[j]);
if(lista[j]<min && lista[j]>0){
min= lista[j];
}
if(lista[j]>max){
max= lista[j];
}
}
System.out.println("El valor mas pequeño: "+ min);
System.out.println("El valor mas grande: "+ max);
}catch (IOException e){
System.out.println(e.getMessage());
}
}

4
 5. Escribe un programa que visualice por pantalla la tabla de multiplicar de los 10
primeros números naturales. Utilizar una función que reciba un número N y devuelva
un array de arrays con las tablas de multiplicar de 0 a 9 de los N números

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class tema1 {

public static int []multiplica(int N){
int []multi= new int[400];
int contador=0;
for(int i=0; i<=N; i++){
for (int j=0; j<=9; j++){
multi[contador]= i*j;
System.out.println(i+" x "+j+ " = "+multi[contador]);
contador++;
}
}
return multi;
}

public static void main(String[] args) {

int N;
try{
BufferedReader teclado= new BufferedReader(new InputStreamReader(System.in));
System.out.println("Dame un numero:");
N= Integer.parseInt(teclado.readLine());
System.out.println("Las tablas de multiplicar hasta ese numero sera: ");
multiplica(N);

}catch (IOException e){

System.out.println(e.getMessage());
}
}

5
 6. Escribe un programa que muestre por pantalla la lista de los N primeros números
primos. Realiza una función que reciba N, devuelve un array conteniendo los N
primeros números primos y posteriormente imprima el array en el main.

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Ej6{

public static boolean esPrimo(int num){
if (num <= 1) {
return false;
}
for (int i = 2; i <= Math.sqrt(num); i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
public static int[] lista(int n){
int[] lista = new int[n];
int contador = 0;
int num = 2;
while (contador < n) {
if (esPrimo(num)) {
lista[contador] = num;
System.out.println("Un número primo es: " + lista[contador]);
contador++;
}
num++;
}
return lista;
}
public static void main(String[] args) {
int n = 0;
try{
do{
BufferedReader consola = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Dame un número positivo: ");
n = Integer.parseInt(consola.readLine());
if (n > 0) {
lista(n);
}
} while (n > 0);

} catch (IOException e){ System.out.println(e.getMessage()); } } }

6
 7. Escribe un programa que lea un número entero de teclado, lo guarde en una variable,
lo envíe a una función que lo descomponga en factores primos, y dicha función
devuelva un array que contenga los factores primos. Posteriormente imprima el array
en el main. ; por ejemplo 40 = 2 * 2 * 2 * 5.

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Ej7{

public static void main(String[] args) {
int N=numero();
int []primos= primos(N);
System.out.println("Los factores primos de "+N+":");
for (int primo : primos) {
System.out.println(primo + "*");
}

}
public static int numero(){
int N=-1;
try{
BufferedReader consola= new BufferedReader(new InputStreamReader(System.in));
System.out.println("Dame un numero positivo: ");
N = Integer.parseInt(consola.readLine());
} catch (IOException ioe) {
System.out.println(ioe);
}
return N;
}
public static int [] primos(int N){
int []factores= new int[N];
int j=0;
for(int i=2; i<=N; i++){
while (N%i==0){
factores[j]=i;
N/=i;
j++;
}
}
int []primo= new int[j];
for(int i=0; i<j; i++){
primo[i]=factores[i];
}
return primo;
} }

7
 8. Empleando un array, escribir un programa que pida al usuario números enteros hasta
que se introduzca el número 0. A continuación, calcular la media, el mínimo y el
máximo de los datos introducidos. Utilice funciones independientes para: a) recibir N
números enteros por teclado hasta que el usuario introduzca un 0; b) Calcule la media
de los elementos de un array; c) calcule el mínimo de los elementos de un array; y d)
Calcule el máximo de los elementos de un array.

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Ej8{

public static void main(String[] args) {
int []lista = pideNumero();
int media= media(lista);
System.out.println("La media de tu lista es de: "+media);
int max= max(lista);
System.out.println("El maximo de tu lista: "+max);
int min= min(lista);
System.out.println("El minimo de tu lista: "+min);

public static int []pideNumero() {

int N;
int []lista= new int[200];
int contador=0;
try{
do{
BufferedReader consola= new BufferedReader(new InputStreamReader(System.in));
System.out.println("Introduce un numero entero y 0 para terminar: ");
N = Integer.parseInt(consola.readLine());
lista[contador]=N;
contador++;
}while(N>0);
}catch (IOException e){
System.out.println(e.getMessage());
}
return lista;
}
public static int media(int []lista){
int media=0;
int suma=0;
int contador=0;

for (int i=0; i< lista.length; i++){

if(lista[i]!=0) {

8
 suma += lista[i];
contador++;
}
}
media=suma/ contador;
return media;
}
public static int max(int []lista){
int max= Integer.MIN_VALUE;
for(int i=0; i< lista.length; i++){
if(lista[i]>max){
max=lista[i];
}
}
return max;
}
public static int min(int []lista){
int min= Integer.MAX_VALUE;
for(int i=0; i< lista.length; i++){
if(lista[i]<min && lista[i] !=0){
min=lista[i];
}
}
return min;
}
}

9
 9. Escribir un programa que solicite al usuario dos vectores de N elementos y que
imprima su producto escalar. Utilice un array para representar el vector de N
elementos. Realice la entrada de usuario por teclado en una función que reciba las
dimensiones del vector a la que se invoca dos veces (una por vector) y otra función que
calcule el producto escalar recibiendo dos arrays que representan dos vectores.

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class tema1{

public static void main(String[] args) {
int v1;
int v2;
try{
BufferedReader consola= new BufferedReader(new InputStreamReader(System.in));
System.out.println("Introduce el numero de elementos del primer vector: ");
v1 = Integer.parseInt(consola.readLine());
int []vector1= vector1(v1);
System.out.println("Introduce el numero de elementos del segundo vector: ");
v2 = Integer.parseInt(consola.readLine());
int []vector2= vector2(v2);
int producto= productoEscalar(v1, v2, vector1, vector2);
System.out.println("El producto escalar es: "+ producto);
}catch (IOException e){
System.out.println(e.getMessage());
}
}

public static int []vector1(int v1){

int []vector= new int [100];//siempre fuera del try-catch
try{
BufferedReader consola= new BufferedReader(new InputStreamReader(System.in));
for(int i=0; i<v1; i++){
System.out.println("Introduce el numero de la posicion "+i);
vector[i]= Integer.parseInt(consola.readLine());
}
}catch (IOException e){
System.out.println(e.getMessage());
}
return vector;
}
public static int []vector2(int v2){
int []vector= new int [100];//siempre fuera del try-catch
try{
BufferedReader consola= new BufferedReader(new InputStreamReader(System.in));
for(int i=0; i<v2; i++){

10
 System.out.println("Introduce el numero de la posicion "+i);
vector[i]= Integer.parseInt(consola.readLine());
}
}catch (IOException e){
System.out.println(e.getMessage());
}
return vector;
}
public static int productoEscalar(int v1, int v2, int []V1, int []V2){
int producto=0;
int suma=0;
for(int i=0; i<v1; i++){
for(int j=0; j<v2; j++){
if(V1[i]!=0 && V2[j]!=0){
producto= V1[i]*V2[j];
suma+=producto;
}
}
}
return suma;
}
}

M
 10. Escribir un programa que rellene una matriz cuadrada (las dimensiones de la matriz
serán un parámetro que se pida al usuario) con números aleatorios de tal modo que la
matriz sea simétrica. Imprimir la matriz por pantalla. Realice todo en una única función
a la que se llama desde el main.

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Random;

public class tema1{

public static void main(String[] args) {
int n=dimension();
int [][]matriz=matriz1(n);
imprimirMatriz(matriz);
}
public static int dimension(){
int n=0;
try{
BufferedReader consola= new BufferedReader(new InputStreamReader(System.in));
System.out.println("Introduce la dimension de la matriz: ");
n= Integer.parseInt(consola.readLine());
}catch (IOException e){
System.out.println(e.getMessage());
}
return n;
}
public static int [][]matriz1(int n){
Random rand= new Random();
int [][]matriz= new int[n][n];
for(int i=0; i<n; i++){
for(int j=i; j<n; j++){
matriz [i][j]= rand.nextInt(100);
matriz [j][i]=matriz [i][j];
}
}
return matriz;
}
public static void imprimirMatriz(int [][]matriz){
System.out.println("La matriz simetrica:");
for (int i=0; i< matriz.length; i++){
for (int j=0; j< matriz.length; j++){
System.out.printf("%5d", matriz[i][j]);
}
System.out.println();
}
} }

12
 11. Escribir un programa que multiplique dos matrices. Sus dimensiones y valores deben
de solicitarse al usuario por teclado y tras realizar la multiplicación debe visualizarse en
pantalla ambas matrices y el resultado de la multiplicación.
Cree una nueva función similar al ejercicio 9 pero que recibirá vectores de varias
dimensiones. Realice otra función multiplicar matrices que reciba dos arrays de dos
dimensiones que representan 2 vectores y devuelva otro array de dos dimensiones que
contenga su multiplicación. En caso de no ser compatibles las dimensiones la función
indicará que ha habido un error.

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Random;

public class tema1{

public static void main(String[] args) {
int n1=dimension();
int [][]matriz1=matriz(n1);
imprimirMatriz(matriz1);
int n2=dimension();
int [][]matriz2=matriz(n2);
imprimirMatriz(matriz2);
int [][]multipica= multiplicacion(matriz1, matriz2);
imprimirMatriz(multipica);
}
public static int dimension(){
int n=0;
try{
BufferedReader consola= new BufferedReader(new InputStreamReader(System.in));
System.out.println("Introduce la dimension de la matriz: ");
n= Integer.parseInt(consola.readLine());
}catch (IOException e){
System.out.println(e.getMessage());
}
return n;
}
public static int [][]matriz(int n){
int [][]matriz= new int[n][n];
BufferedReader consola= new BufferedReader(new InputStreamReader(System.in));
try{
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
System.out.println("Dame el valor de la posicion: ("+i+","+j+") : ");
matriz[i][j]= Integer.parseInt(consola.readLine());
}
}
}catch(IOException e){

13
 System.out.println(e.getMessage());
}
return matriz;
}
public static void imprimirMatriz(int [][]matriz){
System.out.println("Matriz creada:");
for (int i=0; i< matriz.length; i++){
for (int j=0; j< matriz.length; j++){
System.out.printf("%5d", matriz[i][j]);
}
System.out.println();
}
}
public static int [][]multiplicacion(int [][]matriz1, int [][]matriz2){
int dimension=0;
if (matriz1.length>matriz2.length){
dimension=matriz2.length;
}else{
dimension=matriz1.length;
}
int [][]matriz =new int [dimension][dimension];
for(int i=0; i< matriz1.length; i++){
for(int j=0; j< matriz2.length; j++){
matriz[i][j]= matriz1[i][j]*matriz2[i][j];
}
}
return matriz;
}
}

14
 12. Escribe un programa que acepte una cadena de caracteres (que podrá contener
cualquier carácter a excepción del retorno de carro) y que diga cuántas vocales
contiene. Realice la entrada de teclado en una función (lectura de una string) y el
cálculo de vocales de una string en otra función independiente que reciba una string y
devuelva un entero.

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Locale;

public class tema1{

public static void main(String[] args) {
String lista=lista();
int contador= contador(lista);
System.out.println("En tu cadena hay "+contador+" vocales.");
}

public static String lista(){

String lista= " ";
try{
BufferedReader consola= new BufferedReader(new InputStreamReader(System.in));
System.out.println("Dame una cadena caracteres: ");
lista = consola.readLine();

}catch (IOException e){

System.out.println(e.getMessage());
}
return lista;
}
public static int contador(String lista){
int contador=0;
lista= lista.toLowerCase();
for (int i=0; i< lista.length(); i++){
char c= lista.charAt(i);
if(c== 'a' || c== 'e' ||c== 'i' ||c== 'o' ||c== 'u'){
contador++;
}
}
return contador;
}
}

15
 13. Escribe un programa que acepte una cadena de caracteres (que podrá contener
cualquier carácter a excepción del retorno de carro) y que la escriba al revés. Reutiliza
la función del ejercicio para la entrada de teclado y otra función que invierta la cadena.

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class tema1{

public static void main(String[] args) {
String cadena = leerCadena();
String cadenaInvertida = invertirCadena(cadena);
System.out.println("La cadena invertida es: " + cadenaInvertida);
}

public static String leerCadena(){

String cadena = "";
try{
BufferedReader consola = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Introduce una cadena de caracteres: ");
cadena = consola.readLine();
}catch (IOException e){
System.out.println(e.getMessage());
}
return cadena;
}

public static String invertirCadena(String cadena){

String cadenaInvertida = "";
for(int i = cadena.length() - 1; i >= 0; i--){
cadenaInvertida += cadena.charAt(i);
}
return cadenaInvertida;
}
}

16
 14. Escribe un programa que lee una cadena de caracteres de teclado e indique si es o no
palíndroma (se lee igual de izquierda a derecha que de derecha a izquierda, sin tener
en cuenta los espacios en blanco y las mayúsculas). Por ejemplo: "dábale arroz a la
zorra el abad". Reutilice la función del ejercicio 12 para la entrada de teclado y cree
otra función que dada una cadena de caracteres devuelva un boolean indicando si es o
no palíndroma

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Ej14{

public static void main(String[] args) {
String cadena = leerCadena();
boolean esPalindroma= palindroma(cadena);
if(esPalindroma){
System.out.println("Es un palindroma.");
}else{
System.out.println("No es un palindroma. ");
}
}
public static String leerCadena(){
String cadena = "";
try{
BufferedReader consola = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Introduce una cadena de caracteres: ");
cadena = consola.readLine();
}catch (IOException e){
System.out.println(e.getMessage());
}
return cadena;
}
public static boolean palindroma(String cadena) {
cadena = cadena.replaceAll("\\s", "").toLowerCase();
int longitud = cadena.length();
for (int i = 0; i < longitud / 2; i++) {
if (cadena.charAt(i) != cadena.charAt(longitud - i - 1)) {
return false;
}
}
return true;
}
}

17
EJERCICIOS
TEMA 3
 1. Escribe un programa que cree una clase para representar un objeto punto en tres
dimensiones. Proporcionar un constructor que inicialice los valores del punto al origen
de coordenadas y otro que permita especificar las coordenadas del punto. Sobrescribe
su método toString() para que muestre información sobre los puntos. Usa la clase en
un programa donde crees objetos que representen los puntos (12, 13, 18) y (8, 14, 0) y
los muestres por consola.

package org.example;

public class V3D {//creamos la clase del vector de 3 dimensiones

private double x, y, z;//ponemos double para no perder precision

public V3D() {
this.x = 0;
this.y = 0;
this.z = 0;
}
public V3D(double x, double y, double z) {
this.x = x;
this.y = y;
this.z = z;
}
public double getX() {
return x;
}

public double getY() {

return y;
}
public double getZ() {
return z;
}
@Override
public String toString() {
return "(" + x + ", " + y + ", " + z + ")";
}

public static void main(String[] args) {

V3D punto1 = new V3D(12, 13, 18);
V3D punto2 = new V3D(8, 14, 0);
System.out.println("El punto 1 es: " + punto1.toString());
System.out.println("El punto 2 es: " + punto2.toString());
}

18
 2. Crea una clase fecha que almacene el día, el mes y el año de una fecha. Proporciona
funciones miembro para acceder a estos atributos (getDia(), getMes() y getAño() y para
modificarlos (setDia(int dia), setMes(int mes) y setAño(int año)). Sobreescribe su
método toString(). Crea la fecha 20/10/2018. Muéstrala por pantalla. Después cambia
el año 2019. Muéstrala por pantalla.

package org.example;

public class Fecha{ //sin pedir informacion al usuario

private int dia;
private int mes;
private int anio;

public Fecha ( int dia, int mes, int anio) {

this.dia=dia;
this.mes=mes;
this.anio=anio;
}
@Override
public String toString(){
return dia+"/"+mes+"/"+anio;
}
public int getAnio() {
return anio;
}
public int getDia() {
return dia;
}
public int getMes() {
return mes;
}
public void setAnio(int anio) {
this.anio = anio;
}
public void setDia(int dia) {
this.dia = dia;
}
public void setMes(int mes) {
this.mes = mes;
}
public static void main(String[] args) {
Fecha f1= new Fecha (20, 10, 2018);
Fecha f2= new Fecha (20, 10, 2019);
System.out.println("La primera fecha: "+f1);
System.out.println("La segunda fecha: "+f2);
}

19
package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Fecha {

private int dia;
private int mes;
private int anio;

public Fecha ( int dia, int mes, int anio) throws Exception {
try{
setDia(dia);
setMes(mes);
this.anio=anio;
}catch (IOException e){
System.out.println(e.getMessage());
}

}
@Override
public String toString(){
return dia+"/"+mes+"/"+anio;
}
public int getAnio() {
return anio;
}
public int getDia() {
return dia;
}
public int getMes() {
return mes;
}
public void setAnio(int anio) {
this.anio = anio;
}
public void setDia(int dia) throws Exception{
if(dia<1||dia>31){
Exception d= new Exception("El dia no es valido, error");
throw d;
}
this.dia = dia;
}
public void setMes(int mes) throws Exception{
if(mes<1||mes>12){
Exception d= new Exception("El mes no es valido, error");
throw d;
}

20
 this.mes = mes;
}
public static void main(String[] args) {
BufferedReader teclado= new BufferedReader(new InputStreamReader(System.in));
int dia=0;
int mes=0;
int anio=0;
try{
System.out.println("Dame el dia: ");
dia=Integer.parseInt(teclado.readLine());
System.out.println("Dame el mes: ");
mes=Integer.parseInt(teclado.readLine());
System.out.println("Dame el anio: ");
anio=Integer.parseInt(teclado.readLine());
Fecha f1= new Fecha (dia, mes, anio);
System.out.println("Tu fecha es: "+f1);
}catch (IOException i){
System.out.println(i.getMessage());
} catch(Exception e){
System.out.println(e.getMessage());
}

21
 3. Crear una clase que represente un número racional que permita, al menos, sumar,
multiplicar y simplificar números racionales. Proporcionar un constructor por defecto,
un constructor de copia (esto es, un Algoritmos y Estructuras de Datos Página 52 de 56
constructor al que se le pasa una instancia de la clase número racional y crea otro
número racional idéntico), y otro que permita indicar los valores del numerador y del
denominador. Usando esta clase, crea una calculadora que permita operar con
números racionales, seleccionando las operaciones de un menú.

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class NumeroRacional {

private static int numerador;
private static int denominador;

public NumeroRacional(){//constructor por defecto

this.numerador=0;
this.denominador=1;
}
public NumeroRacional ( int numerador, int denomenador) {
this.numerador=numerador;
this.denominador=denomenador;
}
@Override
public String toString(){
return numerador+"/"+denominador;
}
public int getDenominador() {
return denominador;
}
public int getNumerador() {
return numerador;
}
public void setDenominador(int denominador) {
this.denominador = denominador;
}
public void setNumerador(int numerador) {
this.numerador = numerador;
}
public static NumeroRacional suma(NumeroRacional f1, NumeroRacional f2){
int denominador= f1.getDenominador()* f2.getDenominador();
int numerador= f1.getNumerador()* f2.getDenominador()+ f2.getNumerador()*
f1.getDenominador();
return new NumeroRacional(numerador, denominador);
}
public static NumeroRacional resta(NumeroRacional f1, NumeroRacional f2){

22
 int denominador= f1.getDenominador()* f2.getDenominador();
int numerador= f1.getNumerador()* f2.getDenominador()- f2.getNumerador()*
f1.getDenominador();
return new NumeroRacional(numerador, denominador);
}
public static NumeroRacional multiplicacion(NumeroRacional f1, NumeroRacional f2){
int denominador= f1.getDenominador()* f2.getDenominador();
int numerador= f1.getNumerador()* f2.getNumerador();
return new NumeroRacional(numerador, denominador);
}
private static int mcd(int a, int b) {
if (b == 0) {
return a;
} else {
return mcd(b, a % b);
}
}

public static NumeroRacional simplificar(NumeroRacional f1) {

int mcd = mcd(f1.getNumerador(), f1.getDenominador());
return new NumeroRacional(numerador / mcd, denominador / mcd);
}
public static void menu(){
System.out.println("1. Suma");
System.out.println("2. Resta");
System.out.println("3. Multiplicacion");
System.out.println("4. Simplificar");
System.out.println("Opcion: ");
}
public static void main(String[] args) {
BufferedReader teclado= new BufferedReader(new InputStreamReader(System.in));
int numerador1=0;
int denominador1=0;
int numerador2=0;
int denominador2=0;
int opcion=0;
int sub_opcion=0;
try{
System.out.println("Dame un numerador: ");
numerador1=Integer.parseInt(teclado.readLine());
System.out.println("Dame un denominador: ");
denominador1=Integer.parseInt(teclado.readLine());
NumeroRacional f1= new NumeroRacional(numerador1,denominador1);
System.out.println("Tu primer nº racional: "+f1);
System.out.println("Dame un numerador: ");
numerador2=Integer.parseInt(teclado.readLine());
System.out.println("Dame un denominador: ");
denominador2=Integer.parseInt(teclado.readLine());

23
 NumeroRacional f2= new NumeroRacional(numerador2,denominador2);
System.out.println("Tu segundo nº racional: "+f2);
do{
menu();
opcion=Integer.parseInt(teclado.readLine());
switch (opcion){
case 1:
NumeroRacional suma= suma(f1,f2);
System.out.println("La suma de tus racionales es: "+ suma);
NumeroRacional simplicacion= simplificar(suma); //Como aqui declaramos
simplicacion
// como un numero racional se aplica al resto
System.out.println("Tu funcion simplificada: "+simplicacion);

break;
case 2:
NumeroRacional resta= resta(f1, f2);
System.out.println("La resta de tus racionales es: "+ resta);
simplicacion = simplificar(resta);
System.out.println("Tu funcion simplificada: "+simplicacion);

break;
case 3:
NumeroRacional multiplicacion= multiplicacion(f1, f2);
System.out.println("La multiplicacion de tus racionales es: "+ multiplicacion);
simplicacion= simplificar(multiplicacion);
System.out.println("Tu funcion simplificada: "+simplicacion);

break;
case 4:
System.out.println("Que fracion quieres simplificar? ");
System.out.println("Fraccion 1: "+f1);
System.out.println("Fraccion 2: "+f2);
sub_opcion=Integer.parseInt(teclado.readLine());
if(sub_opcion==1){
simplicacion= simplificar(f1);
System.out.println("Tu funcion simplificada: "+simplicacion);
}else if(sub_opcion==2){
simplicacion= simplificar(f2);
System.out.println("Tu funcion simplificada: "+simplicacion);
}else{
System.out.println("Opcion no valida.");
}
break;
default:
System.out.println("Opcion no valida");
}
}while (opcion>0 && opcion<4) }catch (IOException i) Sout (i.getMessage()); } } }

24
 4. Repetir el ejercicio anterior, pero creando una clase que represente a un número
complejo.

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class NumeroComplejo{

private static int real;
private static int imaginario;

public NumeroComplejo(){//constructor por defecto

this.real=0;
this.imaginario=0;
}
public NumeroComplejo ( int real, int imaginario) {
this.real=real;
this.imaginario=imaginario;
}
@Override
public String toString(){
return real+"+"+imaginario+"i";
}
public int getReal() {
return real;
}
public int getImaginario() {
return imaginario;
}
public void setReal(int real) {
this.real = real;
}
public void setImaginario(int imaginario) {
this.imaginario = imaginario;
}
public static NumeroComplejo suma(NumeroComplejo f1, NumeroComplejo f2){
int real= f1.getReal() + f2.getReal();
int imaginario= f1.getImaginario()+ f2.getImaginario();
return new NumeroComplejo(real, imaginario);
}
public static NumeroComplejo resta(NumeroComplejo f1, NumeroComplejo f2){
int real= f1.getReal() - f2.getReal();
int imaginario= f1.getImaginario()- f2.getImaginario();
return new NumeroComplejo(real, imaginario);
}
public static NumeroComplejo multiplicacion(NumeroComplejo f1, NumeroComplejo f2){
int real= f1.getReal()*f2.getReal()- f1.getImaginario()*f2.getImaginario();

25
 int imaginario= f1.getReal()* f2.getImaginario()+f1.getImaginario()*f2.getReal();
return new NumeroComplejo(real, imaginario);
}
public static void menu(){
System.out.println("1. Suma");
System.out.println("2. Resta");
System.out.println("3. Multiplicacion");
System.out.println("Opcion: ");
}
public static void main(String[] args) {
BufferedReader teclado= new BufferedReader(new InputStreamReader(System.in));
int real1=0;
int imaginario1=0;
int real2=0;
int imaginario2=0;
int opcion=0;
try{
System.out.println("Dame un numerador: ");
real1=Integer.parseInt(teclado.readLine());
System.out.println("Dame un denominador: ");
imaginario1=Integer.parseInt(teclado.readLine());
NumeroComplejo f1= new NumeroComplejo(real1,real2);
System.out.println("Tu primer nº racional: "+f1);
System.out.println("Dame un numerador: ");
real2=Integer.parseInt(teclado.readLine());
System.out.println("Dame un denominador: ");
imaginario2=Integer.parseInt(teclado.readLine());
NumeroComplejo f2= new NumeroComplejo(real2,imaginario2);
System.out.println("Tu segundo nº racional: "+f2);
do{
menu();
opcion=Integer.parseInt(teclado.readLine());
switch (opcion){
case 1:
NumeroComplejo suma= suma(f1,f2);
System.out.println("La suma de tus complejos es: "+ suma);
break;
case 2:
NumeroComplejo resta= resta(f1, f2);
System.out.println("La resta de tus complejos es: "+ resta);
break;
case 3:
NumeroComplejo multiplicacion= multiplicacion(f1, f2);
System.out.println("La multiplicacion de tus complejos es: "+ multiplicacion);
break;
default:
System.out.println("Opcion no valida");
}

26
 }while (opcion>0 && opcion<3);

}catch (IOException i){

System.out.println(i.getMessage()); } } }

5. (30 minutos) Haz una clase llamada Persona con atributos: nombre, edad, DNI, sexo (usa una
enumeración), peso y altura. Crea métodos para acceder y modificar todos los atributos. Por
defecto, todos los atributos menos el DNI tendrán valores por defecto según su tipo (0
números, cadena vacía para String, etc.).

Sexo será mujer por defecto. La clase deberá tener los siguientes constructores constructores:
• Un constructor por defecto.

• Un constructor con el nombre, edad y sexo, el resto por defecto.

• Un constructor con todos los atributos como parámetro, menos el DNI.

La clase deberá tener los siguientes métodos:

• calcularIMC(): calcula el índice de masa corporal de la persona (peso en kg/(altura^2 en m))

• valorarPesoCorporal() devuelve un -1 si está por debajo de su peso ideal, un 0 si está en su

peso ideal y un 1 si tiene sobrepeso. Sobrepeso se define como IMC > 25 y se considera que se
está por debajo del peso ideal si IMC<18.

• esMayorDeEdad(): indica si es mayor de edad, devuelve un booleano.

• toString(): devuelve toda la información de la persona como una cadena de caracteres.

• generaDNI(): genera un número aleatorio de 8 cifras que será el DNI de la persona. Este
método no será visible desde el exterior. Este método deberá invocarse desde cualquier
constructor para generar el DNI.

• Métodos set de cada parámetro, excepto de DNI.

Ahora, crea una clase ejecutable que haga lo siguiente:

• Pide por teclado el nombre, la edad, sexo, peso y altura.

• Crea 3 objetos de la clase anterior, el primer objeto obtendrá las anteriores variables pedidas
por teclado, el segundo objeto obtendrá todos los anteriores menos el peso y la altura y el
último por defecto, para este último utiliza los métodos set para darle a los atributos un valor.

• Para cada objeto, se deberá comprobar si está en su peso ideal, tiene sobrepeso o por debajo
de su peso ideal con un mensaje.

• Indicar para cada objeto si es mayor de edad.

• Por último, mostrar la información de cada objeto.

package org.example;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

27
import java.util.Random;

public class Persona {

private String nombre;
private int edad;
private String dni;
private double peso;
private double altura;
private Sexo sexo;
public Persona( String nombre, int edad, String dni, double peso, double altura, Sexo sexo)
throws Exception {
this.nombre=nombre;
this.dni=dni;
this.edad=edad;
this.sexo=sexo;
setAltura(altura);
setPeso(peso);

}
public Persona(){
this.nombre= " ";
this.sexo= Sexo.FEMALE;
this.edad=0;
this.dni=" ";
this.peso=0;
this.altura=0;
}
public Persona(String nombre, int edad, Sexo sexo){
this.nombre= nombre;
this.sexo= sexo;
this.edad=edad;
this.dni=" ";
this.peso=0;
this.altura=0;
}

public void setPeso(double peso) throws Exception {

if(peso<2){
Exception t= new Exception("El peso esta mal");
throw t;
}
this.peso = peso;
}

public void setAltura(double altura) throws Exception {

if(altura<0 && altura>280){
Exception t= new Exception("El peso esta mal");
throw t;

28
 }
this.altura = altura;
}

public static double calcularIMC(double peso, double altura){

double alturametros= altura/100;
double imc= peso/Math.pow(alturametros, 2);
return imc;
}
public static int valorPesoCorporal(double imc){
if(imc>25){
return 1;
}else if(imc<18){
return -1;
}else{
return 0;
}
}
public static boolean esMayorDeEdad(int edad){
if(edad>18){
return true;
}else{
return false;
}
}

public String toStrig(){

return "Nombre: "+nombre+
"DNI: "+dni+
"Edad: "+edad+
"Sexo: "+sexo+
"Peso: "+peso+
"Altura: "+altura;
}
public static String generaDNI(){
int num= (int)(Math.random()*10);
String letraDNI= "ABCDEFGHIJKLMNOPQRSTUVWXYZ".charAt(num%23)+"";
return String.format("%08d", num)+letraDNI; //ponemos s%08d para indicar que el dni va
a tener 8 dígitos
}

public void setSexo(Sexo sexo) {

this.sexo = sexo;
}

public void setEdad(int edad) {

this.edad = edad;
}

29
public void setNombre(String nombre) {
this.nombre = nombre;
}

public Sexo getSexo() {

return sexo;
}

public double getAltura() {

return altura;
}

public double getPeso() {

return peso;
}

public String getDni() {

return dni;
}

public int getEdad() {

return edad;
}

public String getNombre() {

return nombre;
}

public static void main(String[] args) {

BufferedReader teclado= new BufferedReader(new InputStreamReader(System.in));
String nombre= " ";
Sexo sexo= Sexo.FEMALE;
int edad=0;
String dni=" ";
double peso=0;
double altura=0;
try{
System.out.println("Nombre: ");
nombre=teclado.readLine();
System.out.println("Edad: ");
edad=Integer.parseInt(teclado.readLine());
System.out.println("Sexo (male, female): ");
sexo= Sexo.valueOf(teclado.readLine());
System.out.println("Peso: ");
peso= Double.parseDouble(teclado.readLine());
System.out.println("Altura: ");
altura= Double.parseDouble(teclado.readLine());

30
 dni=generaDNI();
double imc= calcularIMC(peso, altura);
System.out.println("Su imc es: "+imc);
int valorC= valorPesoCorporal(imc);
if(valorC== 1){
System.out.println("La persona tiene sobrepeso.");
}else if(valorC== -1){
System.out.println("La persona esta por debajo de su peso ideal");
}else{
System.out.println("La persona esta en su peso ideal.");
}
boolean mayor= esMayorDeEdad(edad);
if(mayor==true){
System.out.println("La persona es mayo de edad");
}else{
System.out.println("La persona es menor de edad");
}
Persona persona1= new Persona(nombre, edad, dni, peso, altura, sexo);
System.out.println("La persona con toda su informacion: "+persona1);
Persona persona2= new Persona(nombre, edad, sexo);
System.out.println("La persona con parte de su informacion: "+persona2);
Persona persona3= new Persona();
System.out.println("La persona con el constructor por defecto: "+ persona3);
}catch (IOException e){
System.out.println(e.getMessage());
}catch (Exception i){
System.out.println(i.getMessage());
}
}
}

public enum Sexo {

MALE, FEMALE
}

3
6. Haz una clase llamada Password que tenga los atributos longitud y contraseña . Por defecto,
la longitud será de 8. Los constructores serán los siguiente:

• Un constructor por defecto que tendrá como contraseña "password".

• Un constructor con la longitud que nosotros le pasemos. Generará una contraseña aleatoria
con esa longitud. Los métodos de esta clase serán:

• esFuerte(): devuelve un booleano si es fuerte o no, para que sea fuerte debe tener más de 2
mayúsculas, más de 1 minúscula y más de 5 números.

• generarPassword(): genera la contraseña del objeto con la longitud que tenga.

• Método get para contraseña y longitud.

• Método set para longitud.

Ahora, crea una clase clase ejecutable:

• Cree un array de Passwords con el tamaño que tú le indiques por teclado.

• Cree un bucle que cree un objeto para cada posición del array. Indica por teclado la longitud
de cada password.

• Crea otro array de booleanos donde se almacene si el password del array de Password es o
no fuerte (usa el bucle anterior).

• Al final, muestra la contraseña y si es o no fuerte (usa el bucle anterior). Usa este simple
formato: contraseña1 valor_booleano1, contraseña2 valor_bololeano2

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Random;

public class Password {

private int longitud;
private String contrasenia;
public Password(){
this.contrasenia="password";
this.longitud=8;
}
public Password(int longitud) throws Exception {
try{
setLongitud(longitud);
}catch (Exception e){
System.out.println(e.getMessage());
}
this.contrasenia= generaContra();
}

32
public void setLongitud(int longitud) throws Exception {
if(longitud>8){
Exception t= new Exception("Has sobrepasado la longitud");
throw t;
}
if(longitud<0){
Exception e= new Exception("La longitud es muy pequenia");
throw e;
}
this.longitud = longitud;
}
public String generaContra(){
StringBuilder constructor = new StringBuilder(this.longitud);
Random random = new Random();
String may = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
String min = "abcdefghijklmnopqrstuvwxyz";
String num = "0123456789";
String symbols = "!@#$%^&*()_-+={[}]|\\:;\"'<,>.?/";
String Caracteres = may + min + num + symbols;
for (int i = 0; i < this.longitud; i++) {
int index = random.nextInt(Caracteres.length());
constructor.append(Caracteres.charAt(index));
}
return constructor.toString();
}
public boolean esFuerte(){
int numMayusculas = 0;
int numMinusculas = 0;
int numNumeros = 0;
for (int i = 0; i < contrasenia.length(); i++) {
char c = contrasenia.charAt(i);
if (Character.isUpperCase(c)) {
numMayusculas++;
} else if (Character.isLowerCase(c)) {
numMinusculas++;
} else if (Character.isDigit(c)) {
numNumeros++;
}
}
return numMayusculas > 2 && numMinusculas > 1 && numNumeros > 5;
}

public int getLongitud() {

return longitud;
}

33
 public String getContrasenia() {
return contrasenia;
}

public static void main(String[] args) {

BufferedReader teclado= new BufferedReader(new InputStreamReader(System.in));
int cantidad=0;
int longitud=0;
try{
System.out.println("¿Cuantas contrasenias quieres crear? ");
cantidad=Integer.parseInt(teclado.readLine());
Password []pass= new Password[cantidad];
boolean []esFuerte= new boolean[cantidad];
for (int i=0; i<cantidad; i++){
System.out.println("De que longitud es tu contrasenia? ");
longitud=Integer.parseInt(teclado.readLine());
Password pass1= new Password(longitud);
pass[i]=pass1;
esFuerte[i]=pass[i].esFuerte();
}
for (int i=0; i<cantidad; i++){
System.out.println("La contrasenia de la posicion"+i+" :"+ pass[i].getContrasenia()+
"\nEs fuerte o no: "+esFuerte[i]);
}

}catch (IOException e){

System.out.println(e.getMessage());
}catch (Exception i){
System.out.println(i.getMessage());
}

}
}

34
10. En una empresa todos los trabajadores tienen un sueldo base de 1000 €. Los jefes tienen
un suplemento de 500 € por cada año que hayan sido jefe de la empresa, y los viajantes
además del sueldo base cobran 300 € por viaje realizado. Crear una clase empleado de la cual
deriven las clases jefe y viajante. Crear una plantilla de una empresa con dos jefes, cinco
viajantes y 15 empleados, e imprimir por consola sus respectivos salarios. Para generar el
número de viajes de los viajantes y la antigüedad de los jefes puedes generar números
aleatorios entre 0 y 10. Emplea el polimorfismo de herencia.

public class Empleado {

public int dinero_trabajador;
public Empleado(){
this.dinero_trabajador=1000;
}

public int getDinero_trabajador() {

return dinero_trabajador;
}
public void setDinero_trabajador(int dinero_trabajador) {
this.dinero_trabajador = dinero_trabajador;
}

@Override
public String toString() {
return "Sueldo empleado corriente: "+dinero_trabajador;
}
}

public class Jefes extends Empleado{

public int anio;
public Jefes(){
int anio=generaAnios();
this.anio= anio*500;
}

public int getAnio() {

return anio;
}

public void setJefe(int anio) {

this.anio = anio;
}
public static int generaAnios(){
int num= (int)(Math.random()*10);
return num;
}

35
public class Viajantes extends Empleado {
public int viajeros;
public Viajantes(){
int viajes=generaViajes();
this.viajeros=viajes*300;
}

public int getViajes() {

return viajeros;
}

public void setViajantes(int viajes) {

this.viajeros = viajes;
}
public static int generaViajes(){
int num= (int)(Math.random()*11);
return num;
}

public class Empresa {

public Jefes []jefes;
public Viajantes []viajeros;
public Empleado []empleados;
public Empresa(int jefes, int viajeros, int empleados){
this.jefes= new Jefes[jefes];
for(int i=0; i<jefes; i++){
this.jefes[i]=new Jefes();
}
this.viajeros= new Viajantes[viajeros];
for (int i=0; i<viajeros; i++){
this.viajeros[i]= new Viajantes();
}
this.empleados= new Empleado[empleados];
for (int i=0; i<empleados; i++){
this.empleados[i]= new Empleado();
}
}

public void setViajeros(Viajantes[] viajeros) {

this.viajeros = viajeros;
}

public void setEmpleados(Empleado[] empleados) {

this.empleados = empleados;
}

36
 public void setJefes(Jefes[] jefes) {
this.jefes = jefes;
}

public Empleado[] getEmpleados() {

return empleados;
}

public Jefes[] getJefes() {

return jefes;
}

public Viajantes[] getViajeros() {

return viajeros;
}

public void imprimir(){

System.out.println("Sueldo de los empleados: ");
for(Empleado emp: empleados){
System.out.println(emp.toString());
}
System.out.println("Sueldo de los jefes: ");
for(Jefes jefe: jefes){
System.out.println("Sueldo jefe: "+ (jefe.getDinero_trabajador()+jefe.getAnio()));
}
System.out.println("Sueldo de los viajantes: ");
for(Viajantes viaj: viajeros){
System.out.println("Sueldo viajante: "+(viaj.getDinero_trabajador()+viaj.getViajes()));
}
}

public static void main(String[] args) {

Empresa empresa1= new Empresa(2, 5, 15);
empresa1.imprimir();
}
}

37
11. Crea la clase cuenta bancaria, que deberá tener como atributos un nombre de titular, una
fecha de apertura, un número de cuenta y un saldo (puedes emplear un número real. La
cuenta deberá tener un método para retirar dinero, otro para ingresar dinero y otro para
transferir dinero a otra cuenta. De una cuenta no se podrá retirar nunca dinero (ni transferir) si
la cantidad de dinero a retirar o transferir es mayor que el saldo.
- Crea una cuenta a plazo fijo, en la cual cuando se retira dinero de algún modo antes de una
fecha de vencimiento (que será otro atributo de esta clase) además del dinero a retirar se
penaliza con un 5% adicional.
- Crea además una cuenta Vip, que tendrá un atributo adicional que es el saldo negativo
máximo que puede tener. En las cuentas Vip uno podrá tener saldo negativo siempre que no
supere este valor.
- A continuación, construye un main que permita crear los tres tipos de cuentas, y transferir
dinero de unas a otras, ingresar dinero y retirar dinero. Almacena las cuentas en un array.
Emplea polimorfismo de herencia.

package org.example.cuentaBancaria;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.time.LocalDate;

public class Main {

public static void main(String[] args) {

BufferedReader teclado= new BufferedReader(new InputStreamReader(System.in));
CuentaBancaria cuentaBancaria1 = null;
CuentaVip cuentaVip1= null;
CuentaPlazo cuentaPlazo1= null;
int opcion=0;
int opcion1=0;
String nombre= " ";
double numeroCuenta=0;
double saldo=0;
double cantidad=0;
LocalDate vencimiento;
try{
System.out.println("Cuenta Bancaria:");
System.out.println("Nombre: ");
nombre=teclado.readLine();
System.out.println("Numero de cuenta: ");
numeroCuenta=Double.parseDouble(teclado.readLine());
System.out.println("Saldo: ");
saldo=Double.parseDouble(teclado.readLine());
cuentaBancaria1= new CuentaBancaria(nombre, numeroCuenta, saldo);

System.out.println("Cuenta Bancaria a plazos:");

System.out.println("Nombre: ");
nombre=teclado.readLine();
System.out.println("Numero de cuenta: ");

38
numeroCuenta=Double.parseDouble(teclado.readLine());
System.out.println("Saldo: ");
saldo=Double.parseDouble(teclado.readLine());
cuentaPlazo1= new CuentaPlazo(nombre, numeroCuenta, saldo);

System.out.println("Cuenta Bancaria Vip:");

System.out.println("Nombre: ");
nombre=teclado.readLine();
System.out.println("Numero de cuenta: ");
numeroCuenta=Double.parseDouble(teclado.readLine());
System.out.println("Saldo: ");
saldo=Double.parseDouble(teclado.readLine());
cuentaVip1= new CuentaVip(nombre, numeroCuenta, saldo);

System.out.println("Elige que quieres hacer: \n"+"1. Retirar dinero\n"+

"2. Ingresar dinero\n"+
"3. Transferir dinero\n"+"OPCION: ");
opcion=Integer.parseInt(teclado.readLine());
switch (opcion){
case 1:
System.out.println("De que cuenta quieres retirar dinero? ");
System.out.println("1. Cuenta Bancaria\n2. Cuenta a Plazos\n3. Cuenta Vip");
opcion1=Integer.parseInt(teclado.readLine());
switch (opcion1){
case 1:
System.out.println("¿Cuanto dinero quieres retirar? ");
cantidad=Double.parseDouble(teclado.readLine());
cuentaBancaria1.retirar(cantidad);
break;
case 2:
System.out.println("¿Cuanto dinero quieres retirar? ");
cantidad=Double.parseDouble(teclado.readLine());
cuentaPlazo1.retirar(cantidad);
break;
case 3:
System.out.println("¿Cuanto dinero quieres retirar? ");
cantidad=Double.parseDouble(teclado.readLine());
cuentaVip1.retirar(cantidad);
break;
}
break;
case 2:
System.out.println("A que cuenta quieres ingresar dinero? ");
System.out.println("1. Cuenta Bancaria\n2. Cuenta a Plazos\n3. Cuenta Vip");
opcion1=Integer.parseInt(teclado.readLine());
switch (opcion1){
case 1:
System.out.println("¿Cuanto dinero quieres ingresar? ");

34
 cantidad=Double.parseDouble(teclado.readLine());
cuentaBancaria1.ingresar(cantidad);
break;
case 2:
System.out.println("¿Cuanto dinero quieres ingresar? ");
cantidad=Double.parseDouble(teclado.readLine());
cuentaPlazo1.ingresar(cantidad);
break;
case 3:
System.out.println("¿Cuanto dinero quieres ingresar? ");
cantidad=Double.parseDouble(teclado.readLine());
cuentaVip1.ingresar(cantidad);
break;
}
break;
case 3:
System.out.println("De que cuenta a que cuenta quieres transferir dinero? ");
System.out.println("1. Cuenta Bancaria--> Cuenta a Plazos");
System.out.println("2. Cuenta Bancaria--> Cuenta a vip");
System.out.println("3. Cuenta a Plazos--> Cuenta Bancaria");
System.out.println("4. Cuenta a Plazos--> Cuenta a Vip");
System.out.println("5. Cuenta vip--> Cuenta Bamcaria");
System.out.println("6. Cuenta vip--> Cuenta a Plazos");
opcion1=Integer.parseInt(teclado.readLine());
switch (opcion1){
case 1:
System.out.println("¿Cuanto dinero quieres ingresar? ");
cantidad=Double.parseDouble(teclado.readLine());
cuentaBancaria1.transferir1(cuentaPlazo1, cantidad);
break;
case 2:
System.out.println("¿Cuanto dinero quieres ingresar? ");
cantidad=Double.parseDouble(teclado.readLine());
cuentaBancaria1.transferir2(cuentaVip1, cantidad);
break;
case 3:
System.out.println("¿Cuanto dinero quieres ingresar? ");
cantidad=Double.parseDouble(teclado.readLine());
cuentaPlazo1.transferir1(cuentaBancaria1, cantidad);
break;
case 4:
System.out.println("¿Cuanto dinero quieres ingresar? ");
cantidad=Double.parseDouble(teclado.readLine());
cuentaPlazo1.transferir2(cuentaVip1, cantidad);
break;
case 5:
System.out.println("¿Cuanto dinero quieres ingresar? ");
cantidad=Double.parseDouble(teclado.readLine());

40
 cuentaVip1.transferir1(cuentaBancaria1, cantidad);
break;
case 6:
System.out.println("¿Cuanto dinero quieres ingresar? ");
cantidad=Double.parseDouble(teclado.readLine());
cuentaVip1.transferir2(cuentaPlazo1, cantidad);
break;
}

}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

public class CuentaBancaria {

public String nombreTitular;
public LocalDate date;
public double numeroCuenta;
public double saldo;

public CuentaBancaria(String nombreTitular, double numeroCuenta, double saldo) {

this.nombreTitular = nombreTitular;
setDate();
this.numeroCuenta = numeroCuenta;
this.saldo = saldo;
}

public double getNumeroCuenta() {

return numeroCuenta;
}

public String getNombreTitular() {

return nombreTitular;
}

public double getSaldo() {

return saldo;
}

public LocalDate getDate() {

return date;
}

public void setDate() {

this.date = LocalDate.now();
}

41
 public void setNombreTitular(String nombreTitular) {
this.nombreTitular = nombreTitular;
}

public void setNumeroCuenta(double numeroCuenta) {

this.numeroCuenta = numeroCuenta;
}

public void setSaldo(double saldo) {

this.saldo = saldo;
}

public double retirar(double cantidad) {

if (saldo >= cantidad) {
double nuevoSaldo = this.saldo - cantidad;
System.out.println("Se ha podido retirar " + cantidad + "euros. " + "\nSaldo actual: " +
nuevoSaldo);
return nuevoSaldo;
} else {
System.out.println("No se ha podido retirar dinero. \nTu saldo sigue siendo de " +
this.saldo + "euros.");
return this.saldo;
}
}

public double ingresar(double cantidad) {

double nuevoSaldo = this.saldo + cantidad;
System.out.println("Dinero ingresado correctamente. \nSaldo actual: " + nuevoSaldo);
return nuevoSaldo;
}

public void transferir(CuentaBancaria cuentaDestino, double cantidad) {

if (cantidad <= this.saldo) {
retirar(cantidad);
cuentaDestino.ingresar(cantidad);
} else {
System.out.println("No se ha podido transferir dinero");
}
}
public void transferir1(CuentaPlazo cuentaDestino, double cantidad) {
if (cantidad <= this.saldo) {
retirar(cantidad);
cuentaDestino.ingresar(cantidad);
} else {
System.out.println("No se ha podido transferir dinero");
}
}
public void transferir2(CuentaVip cuentaDestino, double cantidad) {

42
 if (cantidad <= this.saldo) {
retirar(cantidad);
cuentaDestino.ingresar(cantidad);
} else {
System.out.println("No se ha podido transferir dinero");
}
}
@Override
public String toString() {
return "Nombre: " + nombreTitular + "\nFecha: " + date + "\nNumero cuenta: " +
numeroCuenta + "\nSaldo: " + saldo;
}
}

public class CuentaPlazo {

public String nombreTitular;
public LocalDate date;
public double numeroCuenta;
public double saldo;
public LocalDate vencimiento;

public CuentaPlazo(String nombreTitular, double numeroCuenta, double saldo) {

this.nombreTitular = nombreTitular;
this.numeroCuenta = numeroCuenta;
this.saldo = saldo;
setDate();
setVencimiento();
}

public double getNumeroCuenta() {

return numeroCuenta;
}
public String getNombreTitular() {
return nombreTitular;
}
public double getSaldo() {
return saldo;
}
public LocalDate getDate() {
return date;
}
public void setDate() {
this.date = LocalDate.now();
}
public void setVencimiento() {
int anio=0;
int mes=0;
int dia=0;
BufferedReader teclado= new BufferedReader(new InputStreamReader(System.in));

43
 try {
System.out.println("Fecha de vencimiento:");
System.out.println("Anio: ");
anio = Integer.parseInt(teclado.readLine());
System.out.println("Mes: ");
mes = Integer.parseInt(teclado.readLine());
System.out.println("Dia: ");
dia = Integer.parseInt(teclado.readLine());
vencimiento = LocalDate.of(anio, mes, dia);
System.out.println(vencimiento);
this.vencimiento = vencimiento;
}catch (IOException e){
System.out.println(e.getMessage());
}
}
public void setNombreTitular(String nombreTitular) {
this.nombreTitular = nombreTitular;
}
public void setNumeroCuenta(double numeroCuenta) {
this.numeroCuenta = numeroCuenta;
}
public void setSaldo(double saldo) {
this.saldo = saldo;
}
public double retirar(double cantidad) {
if (saldo >= cantidad) {
double penalizacion= cantidad*1.05;
double nuevoSaldo = this.saldo - penalizacion;
System.out.println("Se ha podido retirar " + cantidad + "euros. " + "\nSaldo actual: " +
nuevoSaldo);
return nuevoSaldo;
} else {
System.out.println("No se ha podido retirar dinero. \nTu saldo sigue siendo de " +
this.saldo + "euros.");
return this.saldo;
}
}

public double ingresar(double cantidad) {

double nuevoSaldo = this.saldo + cantidad;
System.out.println("Dinero ingresado correctamente. \nSaldo actual: " + nuevoSaldo);
return nuevoSaldo;
}

public void transferir(CuentaPlazo cuentaDestino, double cantidad) {

if (cantidad <= this.saldo) {
retirar(cantidad);
cuentaDestino.ingresar(cantidad);

44
 } else {
System.out.println("No se ha podido transferir dinero");
}
}
public void transferir1(CuentaBancaria cuentaDestino, double cantidad) {
if (cantidad <= this.saldo) {
retirar(cantidad);
cuentaDestino.ingresar(cantidad);
} else {
System.out.println("No se ha podido transferir dinero");
}
}
public void transferir2(CuentaVip cuentaDestino, double cantidad) {
if (cantidad <= this.saldo) {
retirar(cantidad);
cuentaDestino.ingresar(cantidad);
} else {
System.out.println("No se ha podido transferir dinero");
}
}
@Override
public String toString() {
return "Nombre: " + nombreTitular + "\nFecha: " + date + "\nNumero cuenta: " +
numeroCuenta + "\nSaldo: " + saldo;
}
}

public class CuentaVip {

public String nombreTitular;
public LocalDate date;
public double numeroCuenta;
public double saldo;

public CuentaVip(String nombreTitular, double numeroCuenta, double saldo) {

this.nombreTitular = nombreTitular;
setDate();
this.numeroCuenta = numeroCuenta;
this.saldo = saldo;
}

public double getNumeroCuenta() {

return numeroCuenta;
}

public String getNombreTitular() {

return nombreTitular;
}

public double getSaldo() {

45
 return saldo;
}

public LocalDate getDate() {

return date;
}

public void setDate() {

this.date = LocalDate.now();
}

public void setNombreTitular(String nombreTitular) {

this.nombreTitular = nombreTitular;
}

public void setNumeroCuenta(double numeroCuenta) {

this.numeroCuenta = numeroCuenta;
}

public void setSaldo(double saldo) {

this.saldo = saldo;
}

public double retirar(double cantidad) {

double nuevoSaldo = this.saldo - cantidad;
System.out.println("Se ha podido retirar " + cantidad + "euros. " + "\nSaldo actual: " +
nuevoSaldo);
return nuevoSaldo;
}

public double ingresar(double cantidad) {

double nuevoSaldo = this.saldo + cantidad;
System.out.println("Dinero ingresado correctamente. \nSaldo actual: " + nuevoSaldo);
return nuevoSaldo;
}

public void transferir(CuentaVip cuentaDestino, double cantidad) {

retirar(cantidad);
cuentaDestino.ingresar(cantidad);
}
public void transferir1(CuentaBancaria cuentaDestino, double cantidad) {
retirar(cantidad);
cuentaDestino.ingresar(cantidad);
}
public void transferir2(CuentaPlazo cuentaDestino, double cantidad) {
retirar(cantidad);
cuentaDestino.ingresar(cantidad);
}

46
 @Override
public String toString() {
return "Nombre: " + nombreTitular + "\nFecha: " + date + "\nNumero cuenta: " +
numeroCuenta + "\nSaldo: " + saldo;
}
}

47
12. Crea una clase fecha que almacene el día, el mes y el año de una fecha. Proporciona
funciones miembro para acceder a estos atributos (getDia(), getMes() y getAño() y para
modificarlos (setDia(int dia), setMes(int mes) y setAño(int año)).
Sobreescribe su método toString().
La clase debe asegurarse de que los valores introducidos para sus miembros, tanto a través de
los constructores como de los métodos modificadores, se corresponden con una fecha válida
(no es necesario tener en cuenta años bisiestos).
Para ello lanzará una excepción en caso de que los datos no sean válidos. Crea la fecha
31/02/2015 y verifica que se lanza la excepción correspondiente. Verifica que esto también
sucede al invocar el método setDia (35).

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Fecha {

private int dia;
private int mes;
private int anio;
public Fecha(int dia, int mes, int anio) throws Exception {
try{
setDia(dia);
setMes(mes);
setAnio(anio);
}catch (Exception e){
System.out.println(e.toString());
}
}

public void setMes(int mes) throws Exception{

if(mes>12 || mes<1){
Exception t= new Exception("MES INCORRECTO");
throw t;
}
this.mes = mes;
}

public void setDia(int dia) throws Exception {

if(dia<1 || dia>diasDelMes(mes, anio)){
Exception t= new Exception("Dia INCORRECTO");
throw t;
}
this.dia = dia;
}
private int diasDelMes(int mes, int anio){
int dia;
switch (mes) {
case 2:

48
 dia = anio % 4 == 0 ? 29 : 28;// "?" representa el if y ":" el else
// es decir si es divisible por 4 entonces el mes tiene 29 dias y si no el mes tiene 28
System.out.println("el mes es bisiesto");
break;
case 4:
case 6:
case 9:
case 11:
dia = 30;
break;
default:
dia = 31;
}
return dia;
}
public void setAnio(int anio) throws Exception{
if(anio<1){
Exception t= new Exception("Anio INCORRECTO");
throw t;
}
this.anio = anio;
}

public int getDia() {

return dia;
}

public int getAnio() {

return anio;
}

public int getMes() {

return mes;
}

@Override
public String toString() {
return dia+"/"+mes+"/"+anio;
}

public static void main(String[] args) throws Exception, IOException {

BufferedReader teclado= new BufferedReader(new InputStreamReader(System.in));
int dia;
int mes;
int anio;
int opcion = 0;
int contador=0;
Fecha []fecha= new Fecha[1000];

49
 try {
do{
System.out.println("Pulse 1 para introducir otra fecha y 0 para salir: ");
opcion=Integer.parseInt(teclado.readLine());
System.out.println("Dia: ");
dia=Integer.parseInt(teclado.readLine());
System.out.println("Mes: ");
mes=Integer.parseInt(teclado.readLine());
System.out.println("Anio: ");
anio=Integer.parseInt(teclado.readLine());
fecha[contador]= new Fecha(dia,mes,anio);
contador++;
}while (opcion!=0);
}catch (IOException e){
System.out.println(e.getMessage());
}
}
}

so
13. Escribir un resolvedor que busque raíces de una función empleando el algoritmo de
Newton-Raphson para encontrar una raíz de una función concreta.
Este método parte de una estimación inicial de la raíz, x0, y va calculando aproximaciones
sucesivas al valor de la misma utilizando la fórmula: xi+1=xi-f(xi)/f'(xi)
Al ser un método iterativo, es necesario tener un criterio para que termine. Puede establecerse
como criterio de terminación que la diferencia entre f(x) y 0 sea menor que un valor e
pequeño.
Además, por seguridad, se debe establecer un número máximo de iteraciones para que el
algoritmo termine, aunque no converja a una solución (de lo contrario, al ejecutarlo en el
ordenador éste podría quedarse bloqueado).

package org.example;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class NewtonRaphson {

public static void main(String[] args) {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
double x0, e;
int maxIter = 100;

System.out.println("Algoritmo de Newton-Raphson para la función f(x) = x^2 – 2 :");

try {
System.out.print("Introduce una estimación inicial x0: ");
x0 = Double.parseDouble(reader.readLine());
System.out.print("Introduce un valor para e (tolerancia del error): ");
e = Double.parseDouble(reader.readLine());

double x = x0;
int iter = 0;

while (iter < maxIter) {

double fx = f(x);
double fpx = fp(x);

if (Math.abs(fx) < e) {
System.out.println("La raíz de la función es: " + x);
return;
}

x = x - fx/fpx;
iter++;
}

System.out.println("No se encontró una raíz con la estimación inicial y tolerancia del

error proporcionadas.");

51
 } catch (IOException ex) {
System.err.println(ex.getMessage());
}
}

public static double f(double x) {

return x*x - 2;
}

public static double fp(double x) {

return 2*x;
}
}

7. Usando las clases del código de ejemplo de los marcianos, construye una guerra donde
combatan 5 naves de los marcianos y 10 naves de los terrícolas.

8. Usando las clases del código de ejemplo del resolvedor de raíces, añade una nueva función
que permita representar un polinomio de grado n. Crea esta función en tu propio paquete.
Utilizando el resolvedor sin modificar ninguna línea de código, busca raíces de tu polinomio.

9. Crea un nuevo método en la clase resolvedor tal que uno pueda especificar una función, y
no sea necesario indicar el intervalo inicial para buscar la raíz. El propio método va a tratar de
buscar un intervalo adecuado. Trata de idear una estrategia adecuada para encontrar ese
intervalo.

32
EJERCICIOS
TEMA 4
 1. Escribe un programa que pida sucesivamente líneas de caracteres al usuario hasta que
este introduzca una "x". Las líneas de caracteres las irá almacenando en un archivo de
texto.

package org.example;
import java.io.BufferedReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;

public class Ejercicio1 {

public static void main(String []arg) {
//leer y introducir cosas de teclado
BufferedReader teclado = new BufferedReader(new
InputStreamReader(System.in));
//inicializamos una cadena vacía
String linea= "";
try {
//se crea un objeto para escribir las líneas en un
archivo de texto
FileWriter escribir = new FileWriter("archivo.txt");
while (!linea.equals("x")){
System.out.println("Dame una linea de caracter
(pulsa x para salir):");
//se lee la línea de texto introducida:
linea = teclado.readLine();
//almacenamos el texto en el archivo
escribir.write(linea+"\n");
}
escribir.close();
System.out.println("El archivo se ha cerrado
correctamente.");
}catch (IOException e){
System.out.println("ERROR: "+e.getMessage());
}
}
}

33
 2. Modificar el programa anterior añadiendo una opción que permita realizar un listado
del archivo de texto. El programa constará de un primer menú donde el usuario indica
si desea listar el contenido del archivo que está en el disco duro o introducir más líneas
de texto. Si realiza el listado, tras mostrar las líneas por pantalla se vuelve al menú
principal. Si está introduciendo líneas de texto y pulsa "x" se vuelve al menú principal.

package org.example;
import java.io.*;

public class Ejercicio2 {

public static void main(String []arg) {
int opcion = 0;
boolean exit= false;
//leer y introducir cosas de teclado
BufferedReader teclado = new BufferedReader(new
InputStreamReader(System.in));
//inicializamos una cadena vacía
String linea = "";
do {
menu();
try {
opcion = Integer.parseInt(teclado.readLine());
switch (opcion) {
case 1:
//se crea un objeto para escribir las líneas en un archivo de texto
FileWriter escribir = new FileWriter("archivo.txt");
while (!linea.equals("x")) {
System.out.println("Dame una linea de caracter
(pulsa x para salir):");
//se lee la línea de texto introducida:
linea = teclado.readLine();
//almacenamos el texto en el archivo
escribir.write(linea + "\n");
}
escribir.close();
System.out.println("El archivo se ha cerrado
correctamente.");
break;
case 2:
System.out.println("Contenido del archivo: ");
FileReader fileReader=
FileReader("archivo.txt");
BufferedReader bufferedReader= new
BufferedReader(fileReader);
String file="";
while ((file= bufferedReader.readLine()) !=null){
System.out.println(file);
}
bufferedReader.close();
fileReader.close();

54
 break;
case 3:
exit=true;
break;
default:
System.out.println("Opción no valida");
break;
}
}catch(IOException e){
System.out.println("ERROR: " + e.getMessage());
}
}while (opcion != 0) ;
}

public static void menu(){

System.out.println("1. Introducir linea de texto en el
archivo.\n");
System.out.println("2. Listar lineas de texto del
archivo.\n");
System.out.println("3. Salir\n");
System.out.println("Opcion: ");
}
}

55
 3. Escribe un programa que pida el nombre de dos archivos al usuario y compruebe si
ambos archivos son o no iguales.

package org.example;
import java.io.*;

public class Ejercicio3 {

public static void main(String[] args) {
String file1;
String file2;
BufferedReader teclado = new BufferedReader(new
InputStreamReader(System.in));
try{
System.out.println("Dame el nombre del primer archivo: ");
file1= teclado.readLine();
System.out.println("Dame el nombre del segundo archivo:
");
file2= teclado.readLine();
boolean iguales=sonIguales(file1,file2);
if(iguales){
System.out.println("Son iguales");
}else{
System.out.println("Son diferentes");
}

}catch (IOException e){

System.out.println(e.getMessage());
}
}

private static boolean sonIguales( String file1, String file2){

try{
// Abrir los archivos para lectura
FileInputStream fis1 = new FileInputStream(file1);
FileInputStream fis2 = new FileInputStream(file2);

// Comparar los contenidos byte por byte

int byte1, byte2;
do {
byte1 = fis1.read();
byte2 = fis2.read();
} while (byte1 == byte2 && byte1 != -1);

// Cerrar los archivos

fis1.close();
fis2.close();

// Determinar si los archivos son iguales

56
 return byte1 == byte2;
}catch (IOException e){
System.out.println("Error al comparar archivos:
"+e.getMessage());
return false;
}
}
}

57
 4. Escribe un programa que cuente el número de palabras que contiene un archivo de
texto; el nombre del archivo de texto será introducido por el usuario.

package org.example;
import java.io.*;

public class Ejercicio4 {

public static void main(String[] args) {
String nombre="";
BufferedReader teclado = new BufferedReader(new
InputStreamReader(System.in));
try{
System.out.println("Dame el nombre del fichero: ");
nombre= teclado.readLine();
int contador= contarPalabras(nombre);
System.out.println("El archivo "+nombre+" tiene
"+contador+" palabras.");
}catch (IOException e){
System.out.println(e.getMessage());
}
}
private static int contarPalabras(String nombre){
int contador=0;
try{
FileReader file= new FileReader(nombre);
BufferedReader leer= new BufferedReader(file);
String linea;
while ((linea= leer.readLine())!=null){
//Divide las línea del archivo en palabras utilizando los espacios en
blanco como separadores. La expresión regular \\s+ indica que se deben
considerar uno o más espacios en blanco como separadores entre las
palabras.
String[]palabra=linea.split("\\s+");
contador+=palabra.length;
}
file.close();
leer.close();
}catch (IOException e){
System.out.println(e.getMessage());
}
return contador;
}
}

58
 5. Escribe un programa que reciba como argumentos un archivo de texto y una palabra a
buscar en ese archivo. El programa debe contar el número de veces que aparece la
palabra en el archivo.

package org.example;

import java.io.*;

public class Ejercicio5 {

public static void main(String[] args) {
String palabra;
String archivo;
int contador;
BufferedReader teclado = new BufferedReader(new
InputStreamReader(System.in));
try {
System.out.println("Dame el nombre del archivo: ");
archivo= teclado.readLine();
System.out.println("Dame la palabra a buscar: ");
palabra= teclado.readLine();
contador=repeticion(archivo, palabra);
System.out.println("En el archivo "+archivo+" encontramos
"+contador+" veces la plabra '"+palabra+"'");
}catch (IOException e){
System.out.println(e.getMessage());
}
}
private static int repeticion(String archivo, String palabra){
int contador=0;
try{
FileReader file= new FileReader(archivo);
BufferedReader leer= new BufferedReader(file);
String linea;
while ((linea= leer.readLine())!=null){
String[]texto=linea.split("\\s+");
for (int i=0; i< texto.length; i++) {
if (texto[i].equals(palabra)) {
contador++;
}
}
}
file.close();
leer.close();
}catch(IOException e){
System.out.println(e.getMessage());
}
return contador;
}
}

59
 6. Crea un programa que permita guardar y cargar del disco duro contactos de una
agenda telefónica. Cada contacto, que deberá representarse mediante una clase,
constará del nombre de una persona, su e-mail y su número de teléfono. El programa
al arrancar, a través de un menú de consola, permitirá al usuario introducir más
contactos, listar los contactos existentes, o salir del programa.

package org.example.Contacto;

public class Contacto {

public String nombre;
public String email;
public int numeroTel;
public Contacto(String nombre, String email, int numeroTel){
this.nombre=nombre;
this.email=email;
this.numeroTel=numeroTel;
}
@Override
public String toString(){
return "Nombre: "+nombre+", Email: "+email+", Telefono:
"+numeroTel+"\n";
}

public String getNombre() {

return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public double getNumeroTel() {
return numeroTel;
}
public void setNumeroTel(int numeroTel) {
this.numeroTel = numeroTel;
}
}

package org.example.Contacto;

import java.io.*;

public class Ejercicio6 {

60
 public static void main(String[] args) {
int opcion=0;
String nombre;
String email;
int numeroTel;
Contacto contacto;
BufferedReader teclado= new BufferedReader(new
InputStreamReader(System.in));
boolean exit=false;
try {
do{
menu();
opcion=Integer.parseInt(teclado.readLine());
switch (opcion){
case 1:
FileWriter agenda = new
FileWriter("archivo.txt", true);
System.out.println("Dame el nombre del
contacto: ");
nombre= teclado.readLine();
System.out.println("Dame el email del
contacto: ");
email= teclado.readLine();
System.out.println("Dame el telefono del
contacto: ");

numeroTel=Integer.parseInt(teclado.readLine());
contacto= new Contacto(nombre, email,
numeroTel);
agenda.write(contacto.toString()+"\n");
agenda.close();
break;
case 2:
System.out.println("Contenido de la agenda:
");
FileReader fileReader= new
FileReader("archivo.txt");
BufferedReader bufferedReader= new
BufferedReader(fileReader);
String file="";
while ((file= bufferedReader.readLine())
!=null){
System.out.println(file);
}
bufferedReader.close();
fileReader.close();
break;
case 3:
exit=true;
break;

6
 default:
System.out.println("Opción no valida");
break;
}
}while (opcion!=0);
}catch (IOException e){
System.out.println(e.getMessage());
}

}
public static void menu(){
System.out.println("1. Introducir contacto en la angenda.\n");
System.out.println("2. Listar contactos.\n");
System.out.println("3. Salir\n");
System.out.println("Opcion: ");
}
}

62
Tipo Test
 1. Cuál de las siguientes afirmaciones es falsa:
(a) Un objeto es una instancia concreta de una clase abstracta
(b) Un objeto es una instancia concreta de una clase

2. Los elementos que definen a un objeto son:

(a) El tipo de visibilidad que tiene asignado: privado o publico
(b)Los atributos que representan su estado y los métodos que representan su comportamiento

3. En relación con el estado de un objeto, para preservar el principio de

encapsulamiento:
(a) Los atributos de nuestra clase deben permanecer públicos, para permitir un acceso total a
la información que almacenamos en los objetos. Sin embargo, aquellos métodos que realicen
operaciones internas (y no deban ser utilizados), deben establecerse como privados.
(b) Debemos establecer la visibilidad mas restrictiva (por ejemplo, privada) en los atributos de
una clase. Así, cualquier software que utilice nuestro objeto solo accederá al estado de los
objetos mediante los métodos que le hayamos permitido utilizar.

4. En el paradigma de la programación orientada a objetos:

(a) Para conseguir una buena eficiencia se recomienda que los programas estén lo mas
acoplados posibles al código.
(b) Se favorece la semántica y la reutilización de código en detrimento de rendimiento.

5. Si tenemos una variable local, declarada dentro del ámbito de un bloque try podemos
afirmar que:
(a) La variable no es visible dentro de los bloques catch y finally.
(b) La variable es visible dentro del bloque finally pero no dentro del bloque catch.

6. El hecho de que un objeto pueda utilizarse en cualquier método que reciba como
parámetro a cualquier instancia de sus clases padre, se denomina:
(a) Herencia
(b)Polimorfismo

7. Gracias al mecanismo de herencia, una clase hija tiene acceso a públicos, protegidos y
amistosos definidos en su clase padre:
(a) Verdadero.
(b) Falso

8. Al hecho de que, dentro de una misma clase existan dos métodos con el mismo
nombre pero diferente numero/tipo de argumentos, se le denomina:
(a) Sobre escritura de métodos
(b) Sobrecarga de métodos

9. Al utilizar un array en Java podemos acceder a la longitud del mismo gracias a que el
atributo que define dicha longitud tiene una visibilidad:
(a) public
(b) protected

10. Una ................. no proporciona ningún tipo de implementación de código, solo

definde signaturas de métodos.
(a) Clase abstracta
(b) Interfaz

63
 11. Cuando una subclase especifica un método que tiene: el mismo nombre, el mismo
numero y el mismo tipo de argumentos que un método declarado en alguna de sus
superclases, esa clase está:
(a) Sobreescribiendo ese método
(b) Sobrecargando ese método

12. Los métodos de una clase pueden devolver objetos.

(a) Verdadero
(b) Falso

13. Los objetos que se declaran dentro de la función main():

(a) Se pueden utilizar dentro de la función main() y en cualquier otra parte del
programa.
(b) Solo pueden utilizarse dentro de función main().

14. ¿Cuál de las siguientes caracteristics de la programación orientada a objetos esta

relacionada con la reutilización de código?
(a) Polimorfismo
(b)Encapsulamiento.

15. Imagine que la clase C hereda de la clase B. Y la clase B hereda de la clase A. Cuando
se cree un objeto de la clase C, ¿Cuál será la secuencia en que se ejecutarán los
constructores?
(a) Primero el constructor C, luego el constructor B y, finalmente, el constructor A.
(b) Primero el constructor A, luego el constructor B y, finalmente, el constructor C.

16. En qué parte de la memoria de almacenamiento de un ordenador se reserva espacio

para un objeto a la hora de realizar la operación de construcción de dicha instancia
determinada de una clase?
(a) En la Pila o Stack
(b) En el Montón o Heap.

17. Una clase de Java puede estar formada por clases, métodos y funciones.
(a) Verdadero
(b) Falso.

18. El polimorfismo paramétrico permite que un objeto pueda utilizarse de forma

diferente en distintos contextos o situaciones.
(a) Verdadero
(b) Falso

19. Las variables y objetos en Java deben liberarse de forma explícita cuando no se vayan
a utilizar más:
(a) Verdadero
(b) Falso.

20. La diferencia entre la lectura de teclado y la lectura en modo texto de un fichero se

encuentra en el Stream al que se conecta el InputStreamReader.
(a) Verdadero
(b) Falso.

64
 21. Los elementos que definen a un objeto son:
a) El tipo de visibilidad que tiene asignado: privado o público.
b) Los atributos que representan su estado y los métodos que representan su comportamiento.

22. El hecho de que un método pueda recibir un número variable de atributos se

denomina:
a) Herencia
b) Polimorfismo

23. Imagine que la clase C hereda de la clase B. Y la clase B hereda de la clase A. Cuando
se cree un objeto de la clase C, ¿cuál será la secuencia en que se ejecutarán los
constructores?
a) Primero el constructor de C, luego constructor de B y, finalmente, el constructor de A
b) Primero el constructor de A, luego constructor de B y, finalmente, el constructor de C

24. Una lista es:

a) Una estructura de datos estática muy utilizada en programación.
b) Una estructura de datos compuesta por nodos que contienen al elemento y uno o dos
punteros a otros nodos.

25. Un algoritmo de ordenación que implemente el método de la burbuja, tiene una

complejidad en el peor caso de:
a) O(n2)
b) O(n3)

26. En relación al estado de un objeto, para preservar el principio de encapsulación:

a)Los atributos de nuestra clase deben permanecer públicos, para permitir un acceso total a la
información que almacenamos en los objetos. Sin embargo, aquellos métodos que realicen
operaciones internas (y no deban ser utilizados). deben establecerse como privados.
b)Debemos establecer la visibilidad más restrictiva (por ejemplo, privada) en los atributos de
una clase. Así, cualquier software que utilice nuestro objeto, sólo accederá al estado de los
objetos mediante los métodos que le hayamos permitido utilizar.

27. Los métodos de una clase no pueden devolver obietos:

a)Verdadero
b)Falso

28. ¿Cuál de las siguientes características de la programación orientada a objetos está

relacionada con la reutilización de código?
a)Abstracción
b)Herencia

29. El tiempo de acceso a un dato en una lista es:

a)O(n)
b)O(1)

30. Un algoritmo de ordenación que implemente el método de inserción, tiene una

complejidad en el peor caso de:
a) O(n2)
b) O(n3)
31. Un algoritmo de ordenación que implemente el método de inserción se basa en la
idea de ir seleccionando el número correspondiente en la lista desordenada que se va
a insertar en la posición última de la lista ordenada:
a) Verdadero
b) Falso

65
El método de búsqueda binaria es un algoritmo para buscar un elemento específico en una lista
ordenada. Este algoritmo comienza dividiendo la lista en dos mitades y comparando el valor
medio con el valor que se está buscando. Si el valor medio es menor que el valor buscado, se
descarta la mitad inferior de la lista, y se realiza la misma operación en la mitad superior de la
lista. Si el valor medio es mayor que el valor buscado, se descarta la mitad superior de la lista y se
realiza la misma operación en la mitad inferior. Este proceso se repite hasta que se encuentra el
valor buscado o se descubre que no está en la lista.

Para que el método de búsqueda binaria funcione correctamente, la lista debe estar ordenada
previamente en orden ascendente o descendente. Además, el método de búsqueda binaria se
utiliza típicamente en listas de tamaño significativo, ya que si la lista es muy pequeña, el costo de
la búsqueda binaria puede ser mayor que el de otros métodos de búsqueda.

66
Ejemplos Tipo
 1. Supongamos que necesitamos desarrollar un programa en Java para llevar un control
de ventas de una tienda. Cada venta está compuesta por un código de producto, una
cantidad vendida y un precio unitario. Se pide implementar una clase Venta con los
siguientes métodos:
• Constructor: que recibe como parámetros el código de producto, la cantidad vendida
y el precio unitario.
• Métodos getters y setters para los atributos de la venta.
• Método calcularTotal: que devuelve el total de la venta (cantidad vendida x precio
unitario).
• Método toString: que devuelve una cadena con los datos de la venta en el formato
"Producto: [código], cantidad: [cantidad], precio unitario: [precio], total: [total]".
Además, se pide implementar una clase Tienda que contenga un arreglo de ventas y que
tenga los siguientes métodos:

• Constructor: que recibe como parámetro el tamaño del arreglo.

• Método agregarVenta: que recibe como parámetros los datos de una venta y la
agrega al arreglo.
• Método calcularTotalVentas: que devuelve el total de todas las ventas realizadas en
la tienda.
• Método promedioVentas: que devuelve el promedio de ventas realizadas en la
tienda.
• Método toString: que devuelve una cadena con los datos de todas las ventas
realizadas en la tienda en el formato "Venta [i]: Producto: [código], cantidad:
[cantidad], precio unitario: [precio], total: [total]".
package org.example.tienda;

public class Venta {

private int codigoProducto;
private int cantidadVendida;
private double precioUnitario;

public Venta(int codigoProducto, int cantidadVendida, double

precioUnitario) {
this.codigoProducto = codigoProducto;
this.cantidadVendida = cantidadVendida;
this.precioUnitario = precioUnitario;
}

public int getCodigoProducto() {

return codigoProducto;
}

public void setCodigoProducto(int codigoProducto) {

this.codigoProducto = codigoProducto;

67
 }

public int getCantidadVendida() {

return cantidadVendida;
}

public void setCantidadVendida(int cantidadVendida) {

this.cantidadVendida = cantidadVendida;
}

public double getPrecioUnitario() {

return precioUnitario;
}

public void setPrecioUnitario(double precioUnitario) {

this.precioUnitario = precioUnitario;
}

public double calcularTotal() {

return cantidadVendida * precioUnitario;
}

@Override
public String toString() {
return "Producto: " + codigoProducto + ", cantidad: " +
cantidadVendida + ", precio unitario: " +
precioUnitario + ", total: " + calcularTotal();
}
}

package org.example.tienda;

public class Tienda {

private Venta[] ventas;
private int numVentas;

public Tienda(int tamVentas) {

ventas = new Venta[tamVentas];
numVentas = 0;
}

public void agregarVenta(int codigoProducto, int

cantidadVendida, double precioUnitario) {
Venta venta = new Venta(codigoProducto, cantidadVendida,
precioUnitario);

68
 ventas[numVentas] = venta;
numVentas++;
}

public double calcularTotalVentas() {

double totalVentas = 0;
for (int i = 0; i < numVentas; i++) {
totalVentas += ventas[i].calcularTotal();
}
return totalVentas;
}

public double promedioVentas() {

if (numVentas == 0) {
return 0;
}
return calcularTotalVentas() / numVentas;
}

@Override
public String toString() {
String resultado = "";
for (int i = 0; i < numVentas; i++) {
resultado += "Venta " + (i+1) + ": " + ventas[i].toString()
+ "\n";
}
return resultado;
}

public static void main(String[] args) {

Tienda tienda = new Tienda(10);

tienda.agregarVenta(1, 5, 10.5);
tienda.agregarVenta(2, 3, 7.75);
tienda.agregarVenta(3, 2, 20.0);

System.out.println("Total de ventas: " +

tienda.calcularTotalVentas());
System.out.println("Promedio de ventas: " +
tienda.promedioVentas());
System.out.println(tienda.toString());
}

69
 2. Supongamos que tenemos un conjunto de figuras geométricas (círculos, cuadrados y
triángulos) representadas por objetos de sus respectivas clases: Circulo, Cuadrado y
Triangulo. Se pide implementar una clase ColeccionFiguras que contenga un arreglo
de figuras y que tenga los siguientes métodos:
• Constructor: que recibe como parámetro el tamaño del arreglo.
• Método agregarFigura: que recibe como parámetro una figura y la agrega al arreglo.
• Método areaTotal: que devuelve el área total de todas las figuras en la colección.
• Método promedioPerimetro: que devuelve el promedio de los perímetros de todas
las figuras en la colección.
• Método toString: que devuelve una cadena con los datos de todas las figuras en la
colección en el formato "Figura [i]: [tipo], área: [área], perímetro: [perímetro]".
package org.example.geometria;

public abstract class Figura {

private double area;
private double perimetro;
//El hecho de que los métodos "calcularArea" y "calcularPerimetro"
// sean declarados como abstractos implica que no se les proporciona
// una implementación en la clase actual y que su implementación
debe
// ser proporcionada en las subclases que extienden la clase actual.
public abstract double calcularArea();
public abstract double calcularPerimetro();

public double getArea() {

return area;
}

public void setArea(double area) {

this.area = area;
}

public double getPerimetro() {

return perimetro;
}

public void setPerimetro(double perimetro) {

this.perimetro = perimetro;
}
}
public class Circulo extends Figura {
private double radio;

70
 public Circulo(double radio) {
this.radio = radio;
calcularArea();
calcularPerimetro();
}

public double getRadio() {

return radio;
}

public void setRadio(double radio) {

this.radio = radio;
calcularArea();
calcularPerimetro();
}
@Override
public void calcularArea() {
setArea(Math.PI * Math.pow(radio, 2));
}
@Override
public void calcularPerimetro() {
setPerimetro(2 * Math.PI * radio);
}
}
public class Cuadrado extends Figura{
private double lado;

public Cuadrado(double lado) {

this.lado = lado;
calcularArea();
calcularPerimetro();
}

public double getLado() {

return lado;
}

public void setLado(double lado) {

this.lado = lado;
calcularArea();
calcularPerimetro();
}
@Override
public void calcularArea() {
setArea(lado * lado);
}

7
@Override
public void calcularPerimetro() {
setPerimetro(4 * lado);
}
}

public class Triangulo extends Figura {

private double lado1;
private double lado2;
private double lado3;
private double altura;

public Triangulo(double lado1, double lado2, double lado3,

double altura) {
this.lado1 = lado1;
this.lado2 = lado2;
this.lado3 = lado3;
this.altura = altura;
calcularArea();
calcularPerimetro();
}

public double getLado1() {

return lado1;
}

public void setLado1(double lado1) {

this.lado1 = lado1;
calcularArea();
calcularPerimetro();
}

public double getLado2() {

return lado2;
}

public void setLado2(double lado2) {

this.lado2 = lado2;
calcularArea();
calcularPerimetro();
}

public double getLado3() {

return lado3;
}

72
 public void setLado3(double lado3) {
this.lado3 = lado3;
calcularArea();
calcularPerimetro();
}

public double getAltura() {

return altura;
}

public void setAltura(double altura) {

this.altura = altura;
calcularArea();
calcularPerimetro();
}
@Override
public void calcularArea() {
setArea((lado1 * altura) / 2);
}
@Override
public void calcularPerimetro() {
setPerimetro(lado1 + lado2 + lado3);
}
}

public class ColeccionFiguras {

private Figura[] figuras;
private int cantidadFiguras;

public ColeccionFiguras(int tamaño) {

figuras = new Figura[tamaño];
cantidadFiguras = 0;
}

public void agregarFigura(Figura figura) {

if (cantidadFiguras < figuras.length) {
figuras[cantidadFiguras] = figura;
cantidadFiguras++;
}
}

public double areaTotal() {

double areaTotal = 0;
for (int i = 0; i < cantidadFiguras; i++) {

73
 areaTotal += figuras[i].calcularArea();
}
return areaTotal;
}

public double promedioPerimetro() {

double promedioPerimetro = 0;
for (int i = 0; i < cantidadFiguras; i++) {
promedioPerimetro += figuras[i].calcularPerimetro();
}
return promedioPerimetro / cantidadFiguras;
}

public String toString() {

String resultado = "";
for (int i = 0; i < cantidadFiguras; i++) {
resultado += "Figura " + (i+1) + ": " +
figuras[i].getClass().getSimpleName() +
", área: " + figuras[i].calcularArea() +
", perímetro: " + figuras[i].calcularPerimetro()
+ "\n";
}
return resultado;
}
}

-4
 3. Supongamos que se desea desarrollar una aplicación para una biblioteca que
permita llevar el control de los préstamos de libros. Se pide implementar las
siguientes clases:
• Una clase Libro que contenga los siguientes atributos: Título del libro (String), Autor
del libro (String), ISBN del libro (String), Cantidad de ejemplares del libro (int).
• Una clase Usuario que contenga los siguientes atributos: Nombre del usuario (String)
y DNI del usuario (String).
• Una clase Prestamo que contenga los siguientes atributos: Libro prestado (objeto de
la clase Libro), Usuario que ha solicitado el préstamo (objeto de la clase Usuario),
Fecha de inicio del préstamo (objeto de la clase LocalDate), Fecha de fin del
préstamo (objeto de la clase LocalDate).
• Una clase Biblioteca que contenga los siguientes métodos:
o Método agregarLibro: que recibe como parámetro un objeto de la clase Libro
y lo agrega a una lista de libros disponibles.
o Método agregarUsuario: que recibe como parámetro un objeto de la clase
Usuario y lo agrega a una lista de usuarios registrados en la biblioteca.
o Método prestarLibro: que recibe como parámetro el ISBN de un libro y el DNI
de un usuario y, si el libro está disponible y el usuario está registrado en la
biblioteca, crea un objeto de la clase Prestamo y lo agrega a una lista de
préstamos realizados.
o Método devolverLibro: que recibe como parámetro el ISBN de un libro y, si
existe un préstamo asociado al libro y aún no ha vencido la fecha de
devolución, actualiza la cantidad de ejemplares disponibles y elimina el
préstamo de la lista de préstamos realizados.
o Método listarLibrosDisponibles: que devuelve una cadena con el título, autor,
ISBN y cantidad de ejemplares disponibles de todos los libros disponibles en
la biblioteca.
o Método listarUsuariosRegistrados: que devuelve una cadena con el nombre y
DNI de todos los usuarios registrados en la biblioteca.
o Método listarPrestamos: que devuelve una cadena con el título, autor, ISBN,
nombre y DNI de los usuarios y fechas de inicio y fin de todos los préstamos
realizados en la biblioteca.
package org.example.biblioteca;
import java.time.LocalDate;

public class Usuario {

private String nombre;
private String dni;
private Prestamo []prestamos;

public Usuario(String nombre, String dni) {

this.nombre = nombre;
this.dni = dni;
this.prestamos= buscarPrestamo();

75
 }

public String getNombre() {

return nombre;
}

public String getDni() {

return dni;
}
public void prestarLibro(Libro libro, LocalDate fechaInicio,
LocalDate fechaFin) {
Prestamo prestamo = new Prestamo(libro, this, fechaInicio,
fechaFin);
this.prestamos.add(prestamo);
libro.prestar();
}
public void devolverLibro(Libro libro, LocalDate
fechaDevolucion) {
Prestamo prestamo = buscarPrestamo(libro);
if (prestamo != null) {
libro.devolver();
prestamo.setFechaFin(fechaDevolucion);
prestamo.remove();
}
}
public void removePrestamo(Prestamo prestamo) {
this.prestamos.remove(prestamo);
}
public Prestamo buscarPrestamo(Libro libro) {
for (Prestamo prestamo : prestamos) {
if (prestamo.getLibroPrestado().equals(libro)) {
return prestamo;
}
}
return null;
}
}
package org.example.biblioteca;
import java.time.LocalDate;

public class Prestamo {

private Libro libroPrestado;
private Usuario usuario;
private LocalDate fechaInicio;
private LocalDate fechaFin;

76
 public Prestamo(Libro libroPrestado, Usuario usuario, LocalDate
fechaInicio, LocalDate fechaFin) {
this.libroPrestado = libroPrestado;
this.usuario = usuario;
this.fechaInicio = fechaInicio;
this.fechaFin = fechaFin;
}

public Libro getLibroPrestado() {

return libroPrestado;
}

public Usuario getUsuario() {

return usuario;
}

public LocalDate getFechaInicio() {

return fechaInicio;
}

public LocalDate getFechaFin() {

return fechaFin;
}
public Usuario getUsuarioSolicitante() {
return usuario;
}

public void setFechaFin(LocalDate fechaFin) {

this.fechaFin = fechaFin;
}

public void setFechaInicio(LocalDate fechaInicio) {

this.fechaInicio = fechaInicio;
}

public void setLibroPrestado(Libro libroPrestado) {

this.libroPrestado = libroPrestado;
}

public void setUsuario(Usuario usuario) {

this.usuario = usuario;
}

public void remove() {

usuario.removePrestamo(this);
}

78
}
package org.example.biblioteca;

public class Libro {

private String titulo;
private String autor;
private String isbn;
private int cantidadEjemplares;
private boolean prestado;

public Libro(String titulo, String autor, String isbn, int

cantidadEjemplares) {
this.titulo = titulo;
this.autor = autor;
this.isbn = isbn;
this.prestado=false;
this.cantidadEjemplares = cantidadEjemplares;
}

public String getTitulo() {

return titulo;
}

public String getAutor() {

return autor;
}

public String getIsbn() {

return isbn;
}

public int getCantidadEjemplares() {

return cantidadEjemplares;
}
public void setCantidadEjemplares(int cantidadEjemplares) {
this.cantidadEjemplares = cantidadEjemplares;
}
public boolean estaPrestado() {
return prestado;
}
public void prestar() {
this.prestado = true;
}
public void devolver() {
this.prestado = false;
}

79
}
package org.example.biblioteca;
import java.time.LocalDate;

public class Biblioteca {

private Libro[] librosDisponibles;
private Usuario[] usuariosRegistrados;
private Prestamo[] prestamosRealizados;
private int numLibrosDisponibles;
private int numUsuariosRegistrados;
private int numPrestamosRealizados;

public Biblioteca(int maxLibros, int maxUsuarios, int

maxPrestamos) {
this.librosDisponibles = new Libro[maxLibros];
this.usuariosRegistrados = new Usuario[maxUsuarios];
this.prestamosRealizados = new Prestamo[maxPrestamos];
this.numLibrosDisponibles = 0;
this.numUsuariosRegistrados = 0;
this.numPrestamosRealizados = 0;
}

public void agregarLibro(Libro libro) {

if (numLibrosDisponibles < librosDisponibles.length) {
librosDisponibles[numLibrosDisponibles] = libro;
numLibrosDisponibles++;
} else {
System.out.println("No se pueden agregar más libros, la
biblioteca está llena.");
}
}

public void agregarUsuario(Usuario usuario) {

if (numUsuariosRegistrados < usuariosRegistrados.length) {
usuariosRegistrados[numUsuariosRegistrados] = usuario;
numUsuariosRegistrados++;
} else {
System.out.println("No se pueden agregar más usuarios,
la biblioteca está llena.");
}
}

public void prestarLibro(String isbn, String dni, int

diasPrestamo) {
Libro libroPrestado = null;
Usuario usuarioSolicitante = null;

80
 // Buscamos el libro por su ISBN en la lista de libros
disponibles
for (int i = 0; i < numLibrosDisponibles; i++) {
if (librosDisponibles[i].getIsbn().equals(isbn)) {
libroPrestado = librosDisponibles[i];
break;
}
}

// Buscamos al usuario por su DNI en la lista de usuarios

registrados
for (int i = 0; i < numUsuariosRegistrados; i++) {
if (usuariosRegistrados[i].getDni().equals(dni)) {
usuarioSolicitante = usuariosRegistrados[i];
break;
}
}

if (libroPrestado != null && usuarioSolicitante != null) {

if (libroPrestado.getCantidadEjemplares() > 0) {
LocalDate fechaInicio = LocalDate.now();
LocalDate fechaFin =
fechaInicio.plusDays(diasPrestamo);
Prestamo prestamo = new Prestamo(libroPrestado,
usuarioSolicitante, fechaInicio, fechaFin);

if (numPrestamosRealizados <
prestamosRealizados.length) {
prestamosRealizados[numPrestamosRealizados] =
prestamo;
numPrestamosRealizados++;
} else {
System.out.println("No se pueden realizar más
préstamos, la biblioteca ha alcanzado el límite.");
return;
}

libroPrestado.setCantidadEjemplares(libroPrestado.getCantidadEjempla
res() - 1);
System.out.println("El libro " +
libroPrestado.getTitulo() + " ha sido prestado a " +
usuarioSolicitante.getNombre() + ".");
} else {
System.out.println("El libro " +

8
libroPrestado.getTitulo() + " ha sido prestado a " +
usuarioSolicitante.getNombre() + ".");
} else {
System.out.println("El libro " +
libroPrestado.getTitulo() + " no está disponible en este momento.");
}
} else {
System.out.println("El libro o el usuario no están
registrados.");
}
}
public void devolverLibro(String isbn) {
Prestamo prestamoEncontrado = null;
for (Prestamo prestamo : prestamosRealizados) {
if (prestamo.getLibroPrestado().getIsbn().equals(isbn)
&& prestamo.getFechaFin().isAfter(LocalDate.now())) {
prestamoEncontrado = prestamo;

prestamo.getLibroPrestado().setCantidadEjemplares(prestamo.getLibroP
restado().getCantidadEjemplares() + 1);
break;
}
}
if (prestamoEncontrado != null) {
prestamosRealizados.remove(prestamoEncontrado);
System.out.println("El libro " +
prestamoEncontrado.getLibroPrestado().getTitulo() + " ha sido
devuelto correctamente.");
} else {
System.out.println("No existe un préstamo activo para el
libro con ISBN " + isbn + ".");
}
}

public String listarLibrosDisponibles() {

StringBuilder sb = new StringBuilder();
for (Libro libro : librosDisponibles) {
if (libro.getCantidadEjemplares() > 0) {
sb.append("Título: " + libro.getTitulo() + ", Autor:
" + libro.getAutor() + ", ISBN: " + libro.getIsbn() + ", Cantidad de
ejemplares disponibles: " + libro.getCantidadEjemplares() + "\n");
}
}
return sb.toString();
}

82
 public String listarUsuariosRegistrados() {
StringBuilder sb = new StringBuilder();
for (Usuario usuario : usuariosRegistrados) {
sb.append("Nombre: " + usuario.getNombre() + ", DNI: " +
usuario.getDni() + "\n");
}
return sb.toString();
}

public String listarPrestamos() {

StringBuilder sb = new StringBuilder();
for (Prestamo prestamo : prestamosRealizados) {
sb.append("Título: " +
prestamo.getLibroPrestado().getTitulo() + ", Autor: " +
prestamo.getLibroPrestado().getAutor() + ", ISBN: " +
prestamo.getLibroPrestado().getIsbn() + ", Usuario: " +
prestamo.getUsuarioSolicitante().getNombre() + ", DNI: " +
prestamo.getUsuarioSolicitante().getDni() + ", Fecha de inicio: " +
prestamo.getFechaInicio() + ", Fecha de fin: " +
prestamo.getFechaFin() + "\n");
}
return sb.toString();
}
}

83
 4. Se desea implementar una clase en Java que represente una empresa que tiene
empleados. La empresa tiene un jefe, que es un empleado con una serie de
privilegios, como por ejemplo, poder contratar y despedir empleados, y un conjunto
de empleados regulares. Cada empleado tiene un nombre, un número de
identificación y un salario. Además, los empleados regulares tienen un número de
horas trabajadas.
• La clase Empresa deberá tener los siguientes métodos:
o Contratar un empleado regular, el cual será añadido al conjunto de
empleados.
o Despedir un empleado regular, el cual será eliminado del conjunto de
empleados.
o Aumentar el salario de un empleado, dada su identificación.
o Añadir horas trabajadas a un empleado regular, dada su identificación.
o Obtener la cantidad total de salarios que paga la empresa.
o Obtener el empleado con el salario más alto.
• La clase Empleado debe tener los siguientes métodos:
o Devolver el nombre del empleado.
o Devolver la identificación del empleado.
o Devolver el salario del empleado.
• La clase Jefe debe heredar de la clase Empleado e incluir los siguientes métodos:
o Contratar un empleado regular.
o Despedir un empleado regular.
o Aumentar el salario de un empleado regular.
o Obtener la cantidad total de salarios que paga la empresa.
o Obtener el empleado con el salario más alto.
package org.example.empresa;

public class Empleado {

private String nombre;
private int identificacion;
private double salario;

public Empleado(String nombre, int identificacion, double

salario) {
this.nombre = nombre;
this.identificacion = identificacion;
this.salario = salario;
}
public String getNombre() {
return nombre;
}

public int getIdentificacion() {

return identificacion;

84
 }

public double getSalario() {

return salario;
}

public void aumentarSalario(double porcentaje) {

salario = salario * (1 + porcentaje/100);
}

public void setSalario(double salario) {

this.salario = salario;
}

public void setIdentificacion(int identificacion) {

this.identificacion = identificacion;
}

public void setNombre(String nombre) {

this.nombre = nombre;
}
}
ackage org.example.empresa;

public class EmpleadoRegular extends Empleado {

private int horasTrabajadas;

public EmpleadoRegular(String nombre, int identificacion, double

salario) {
super(nombre, identificacion, salario);
horasTrabajadas = 0;
}

public int getHorasTrabajadas() {

return horasTrabajadas;
}

public void agregarHorasTrabajadas(int horas) {

horasTrabajadas += horas;
}
}

package org.example.empresa;

public class Jefe extends Empleado {

private EmpleadoRegular []empleados;

85
 private int cantidadEmpleados;

public Jefe(String nombre, int identificacion, double salario) {

super(nombre, identificacion, salario);
empleados = new EmpleadoRegular[10];
cantidadEmpleados=0;
}

public void contratarEmpleadoRegular(EmpleadoRegular empleado) {

empleados[cantidadEmpleados]=empleado;
cantidadEmpleados++;
}

public void despedirEmpleadoRegular(int identificacion) {

for (int i = 0; i < cantidadEmpleados; i++) {
if (empleados[i].getIdentificacion() == identificacion)
{
// shift the remaining employees in the array to
fill the gap
for (int j = i; j < cantidadEmpleados - 1; j++) {
empleados[j] = empleados[j + 1];
}
cantidadEmpleados--;
empleados[cantidadEmpleados] = null; // remove the
last element
return;
}
}
}

public void aumentarSalarioEmpleadoRegular(int identificacion,

double aumento) {
for (int i = 0; i < cantidadEmpleados; i++) {
if (empleados[i].getIdentificacion() == identificacion)
{
empleados[i].aumentarSalario(aumento);
return;
}
}
}

public double calcularTotalSalarios() {

double total = getSalario();
for (int i = 0; i < cantidadEmpleados; i++) {
total += empleados[i].getSalario();
}

86
 return total;
}

public Empleado empleadoSalarioMasAlto() {

Empleado empleadoMasAlto = this;
for (int i = 0; i < cantidadEmpleados; i++) {
if (empleados[i].getSalario() >
empleadoMasAlto.getSalario()) {
empleadoMasAlto = empleados[i];
}
}
return empleadoMasAlto;
}
}
package org.example.empresa;

public class Empresa {

private Empleado jefe;
private Empleado[] empleadosRegulares;
private int cantidadEmpleadosRegulares;

public Empresa() {
empleadosRegulares = new Empleado[100]; // se asume un
máximo de 100 empleados regulares
cantidadEmpleadosRegulares = 0;
}

public void contratarEmpleadoRegular(String nombre, int

identificacion, double salario, int horasTrabajadas) {
Empleado empleado = new Empleado (nombre, identificacion,
salario);
empleadosRegulares[cantidadEmpleadosRegulares] = empleado;
cantidadEmpleadosRegulares++;
}

public void despedirEmpleadoRegular(int identificacion) {

for (int i = 0; i < cantidadEmpleadosRegulares; i++) {
if (empleadosRegulares[i].getIdentificacion() ==
identificacion) {
empleadosRegulares[i] = null;
for (int j = i; j < cantidadEmpleadosRegulares-1;
j++) {
empleadosRegulares[j] = empleadosRegulares[j+1];
}
cantidadEmpleadosRegulares--;

87
 break;
}
}
}

public void aumentarSalario(int identificacion, double

incremento) {
Empleado empleado = buscarEmpleado(identificacion);
if (empleado != null) {
double nuevoSalario = empleado.getSalario() * (1 +
incremento/100);
empleado.setSalario(nuevoSalario);
}
}

public void agregarHorasTrabajadas(int identificacion, int

horas) {
Empleado empleado = buscarEmpleado(identificacion);
if (empleado instanceof EmpleadoRegular) {
((EmpleadoRegular)
empleado).agregarHorasTrabajadas(horas);
}
}

public double obtenerTotalSalarios() {

double total = 0;
if (jefe != null) {
total += jefe.getSalario();
}
for (int i = 0; i < cantidadEmpleadosRegulares; i++) {
total += empleadosRegulares[i].getSalario();
}
return total;
}

public Empleado obtenerEmpleadoSalarioMasAlto() {

Empleado empleadoSalarioMasAlto = jefe;
for (int i = 0; i < cantidadEmpleadosRegulares; i++) {
if (empleadosRegulares[i].getSalario() >
empleadoSalarioMasAlto.getSalario()) {
empleadoSalarioMasAlto = empleadosRegulares[i];
}
}
return empleadoSalarioMasAlto;
}

88
 private Empleado buscarEmpleado(int identificacion) {
if (jefe != null && jefe.getIdentificacion() ==
identificacion) {
return jefe;
}
for (int i = 0; i < cantidadEmpleadosRegulares; i++) {
if (empleadosRegulares[i].getIdentificacion() ==
identificacion) {
return empleadosRegulares[i];
}
}
return null;
}
}

89
 5. Se desea implementar una clase en Java que represente una lista enlazada de
números enteros. La clase debe tener los siguientes métodos:
• add(int x): Añade un elemento al final de la lista.
• insert(int x, int i): Inserta un elemento en la posición i de la lista.
• remove(int i): Elimina el elemento en la posición i de la lista.
• get(int i): Devuelve el elemento en la posición i de la lista.
• size(): Devuelve el número de elementos en la lista.
• clear(): Elimina todos los elementos de la lista.
• toString(): Devuelve una cadena de caracteres que representa la lista, en el
formato [elemento1, elemento2, ..., elementoN].
La clase deberá tener un constructor por defecto que cree una lista vacía.
package org.example.LinkedList;

public class Node {

int data;
Node next;

public Node(int data) {

this.data = data;
this.next = null;
}

public Node getNext() {

return next;
}

public int getData() {

return data;
}

public void setData(int data) {

this.data = data;
}

public void setNext(Node next) {

this.next = next;
} package org.example.LinkedList;

public class LinkedList {

private Node head;
private int size;

public LinkedList() {
this.head = null;

90
 this.size = 0;
}

public void add(int x) {

if (head == null) {
head = new Node(x);
} else {
Node current = head;
while (current.next != null) {
current = current.next;
}
current.next = new Node(x);
}
size++;
}

public void insert(int x, int i) {

if (i < 0 || i > size) {
throw new IndexOutOfBoundsException();
} else if (i == 0) {
Node newNode = new Node(x);
newNode.next = head;
head = newNode;
} else {
Node current = head;
for (int j = 0; j < i - 1; j++) {
current = current.next;
}
Node newNode = new Node(x);
newNode.next = current.next;
current.next = newNode;
}
size++;
}

public void remove(int i) {

if (i < 0 || i >= size) {
throw new IndexOutOfBoundsException();
} else if (i == 0) {
head = head.next;
} else {
Node current = head;
for (int j = 0; j < i - 1; j++) {
current = current.next;
}
current.next = current.next.next;

91
 }
size--;
}

public int get(int i) {

if (i < 0 || i >= size) {
throw new IndexOutOfBoundsException();
}
Node current = head;
for (int j = 0; j < i; j++) {
current = current.next;
}
return current.data;
}

public int size() {

return size;
}

public void clear() {

head = null;
size = 0;
}

public String toString() {

String result = "[";
Node current = head;
while (current != null) {
result += current.data;
if (current.next != null) {
result += ", ";
}
current = current.next;
}
result += "]";
return result;
}
}

92
 6. Se desea implementar una clase en Java que represente un árbol binario de
búsqueda de números enteros. La clase debe tener los siguientes métodos:
• insert(int x): Inserta un elemento en el árbol binario de búsqueda.
• remove(int x): Elimina un elemento del árbol binario de búsqueda.
• contains(int x): Indica si el árbol binario de búsqueda contiene el elemento x.
• size(): Devuelve el número de elementos en el árbol binario de búsqueda.
• clear(): Elimina todos los elementos del árbol binario de búsqueda.
• inOrderTraversal(): Devuelve una lista con los elementos del árbol binario de
búsqueda en orden ascendente.
• preOrderTraversal(): Devuelve una lista con los elementos del árbol binario de
búsqueda en preorden.
• postOrderTraversal(): Devuelve una lista con los elementos del árbol binario
de búsqueda en postorden.
La clase deberá tener un constructor por defecto que cree un árbol binario de búsqueda
vacío.
package org.example;

public class ArbolBinarioBusqueda {

private Nodo raiz;
private int size;

private class Nodo {

int valor;
Nodo izquierdo;
Nodo derecho;

public Nodo(int valor) {

this.valor = valor;
}
}

public ArbolBinarioBusqueda() {
raiz = null;
size = 0;
}

public void insert(int valor) {

raiz = insertRec(raiz, valor);
size++;
}

private Nodo insertRec(Nodo raiz, int valor) {

if (raiz == null) {
raiz = new Nodo(valor);

93
 return raiz;
}

if (valor < raiz.valor)

raiz.izquierdo = insertRec(raiz.izquierdo, valor);
else if (valor > raiz.valor)
raiz.derecho = insertRec(raiz.derecho, valor);

return raiz;
}

public void remove(int x) {

raiz = removeRec(raiz, x);
size--;
}

private Nodo removeRec(Nodo raiz, int valor) {

if (raiz == null)
return raiz;

if (valor < raiz.valor)

raiz.izquierdo = removeRec(raiz.izquierdo, valor);
else if (valor > raiz.valor)
raiz.derecho = removeRec(raiz.derecho, valor);
else {
if (raiz.izquierdo == null)
return raiz.derecho;
else if (raiz.derecho == null)
return raiz.izquierdo;

raiz.valor = minValue(raiz.derecho);

raiz.derecho = removeRec(raiz.derecho, raiz.valor);

}

return raiz;
}

private int minValue(Nodo nodo) {

int minVal = nodo.valor;
while (nodo.izquierdo != null) {
minVal = nodo.izquierdo.valor;
nodo = nodo.izquierdo;
}
return minVal;
}

94
 public boolean contains(int valor) {
return containsRec(raiz, valor);
}

private boolean containsRec(Nodo raiz, int valor) {

if (raiz == null)
return false;

if (valor == raiz.valor)
return true;

if (valor < raiz.valor)

return containsRec(raiz.izquierdo, valor);
else
return containsRec(raiz.derecho, valor);
}
public int size() {
return size;
}
public void clear() {
raiz = null;
size = 0;
}
public int[] inOrderTraversal() {
int[] lista = new int[size];
inOrderTraversalRec(raiz, lista, 0);
return lista;
}

private int inOrderTraversalRec(Nodo raiz, int[] lista, int

index) {
if (raiz != null) {
index = inOrderTraversalRec(raiz.izquierdo, lista,
index);
lista[index++] = raiz.valor;
index = inOrderTraversalRec(raiz.derecho, lista, index);
}
return index;
}

public int[] preOrderTraversal() {

int[] lista = new int[size];
preOrderTraversalRec(raiz, lista, 0);
return lista;
}

95
 private int preOrderTraversalRec(Nodo raiz, int[] lista, int
index) {
if (raiz != null) {
lista[index++] = raiz.valor;
index = preOrderTraversalRec(raiz.izquierdo, lista,
index);
index = preOrderTraversalRec(raiz.derecho, lista,
index);
}
return index;
}

public int[] postOrderTraversal() {

int[] lista = new int[size];
postOrderTraversalRec(raiz, lista, 0);
return lista;
}

private int postOrderTraversalRec(Nodo raiz, int[] lista, int

index) {
if (raiz != null) {
index = postOrderTraversalRec(raiz.izquierdo, lista,
index);
index = postOrderTraversalRec(raiz.derecho, lista,
index);
lista[index++] = raiz.valor;
}
return index;
}

96
 7. Se te pide que implementes una clase en Java llamada MyArrayList que simule el
comportamiento de un ArrayList en Java. La clase deberá tener los siguientes
métodos públicos:
• MyArrayList(): constructor por defecto que inicializa un ArrayList vacío.
• MyArrayList(int initialCapacity): constructor que inicializa un ArrayList
con la capacidad especificada.
• int size(): devuelve el número de elementos en el ArrayList.
• boolean isEmpty(): devuelve true si el ArrayList está vacío, false en caso
contrario.
• boolean contains(Object o): devuelve true si el ArrayList contiene el objeto
especificado, false en caso contrario.
• int indexOf(Object o): devuelve el índice de la primera aparición del objeto
especificado en el ArrayList, o -1 si el objeto no está presente.
• int lastIndexOf(Object o): devuelve el índice de la última aparición del
objeto especificado en el ArrayList, o -1 si el objeto no está presente.
• Object[] toArray(): devuelve un array con los elementos del ArrayList.
• Object get(int index): devuelve el elemento en la posición especificada en el
ArrayList.
• Object set(int index, Object element): reemplaza el elemento en la
posición especificada en el ArrayList con el elemento especificado, y devuelve el
elemento original.
• boolean add(Object o): agrega el objeto especificado al final del ArrayList, y
devuelve true.
• void add(int index, Object element): agrega el elemento especificado en
la posición especificada en el ArrayList. Los elementos a partir de esa posición se
desplazan hacia la derecha.
• boolean remove(Object o): elimina la primera aparición del objeto
especificado en el ArrayList, si está presente. Devuelve true si se encontró y eliminó
el objeto, false en caso contrario.
• Object remove(int index): elimina el elemento en la posición especificada en
el ArrayList, y devuelve el elemento eliminado.
• void clear(): elimina todos los elementos del ArrayList.
Deberás implementar la clase MyArrayList y todos sus métodos.
Nota: puedes utilizar arrays de Java para implementar el almacenamiento de los elementos
en la clase MyArrayList.
package org.example;

public class MyArrayList {

private Object[] array;
private int size;

public MyArrayList() {

97
 this.array = new Object[10];
this.size = 0;
}

public MyArrayList(int initialCapacity) {

if (initialCapacity < 0) {
throw new IllegalArgumentException("Initial capacity
cannot be negative: " + initialCapacity);
}
this.array = new Object[initialCapacity];
this.size = 0;
}

public int size() {

return this.size;
}

public boolean isEmpty() {

return this.size == 0;
}

public boolean contains(Object o) {

return indexOf(o) != -1;
}

public int indexOf(Object o) {

if (o == null) {
for (int i = 0; i < this.size; i++) {
if (this.array[i] == null) {
return i;
}
}
} else {
for (int i = 0; i < this.size; i++) {
if (o.equals(this.array[i])) {
return i;
}
}
}
return -1;
}

public int lastIndexOf(Object o) {

if (o == null) {
for (int i = this.size - 1; i >= 0; i--) {
if (this.array[i] == null) {

98
 return i;
}
}
} else {
for (int i = this.size - 1; i >= 0; i--) {
if (o.equals(this.array[i])) {
return i;
}
}
}
return -1;
}

public Object get(int index) {

if (index < 0 || index >= this.size) {
throw new IndexOutOfBoundsException("Index out of
bounds: " + index);
}
return this.array[index];
}

public Object set(int index, Object element) {

if (index < 0 || index >= this.size) {
throw new IndexOutOfBoundsException("Index out of
bounds: " + index);
}
Object oldElement = this.array[index];
this.array[index] = element;
return oldElement;
}

public boolean add(Object o) {

if (this.size == this.array.length) {
// Lógica de redimensionamiento del array
Object[] newArray = new Object[this.array.length + 10];
System.arraycopy(this.array, 0, newArray, 0,
this.array.length);
this.array = newArray;
}
this.array[this.size] = o;
this.size++;
return true;
}

public void add(int index, Object element) {

94
 if (index < 0 || index > this.size) {
throw new IndexOutOfBoundsException("Index out of
bounds: " + index);
}
if (this.size == this.array.length) {
Object[] newArray = new Object[this.array.length * 2];
System.arraycopy(this.array, 0, newArray, 0,
this.array.length);
this.array = newArray;
}
System.arraycopy(this.array, index, this.array, index + 1,
this.size - index);
this.array[index] = element;
this.size++;
}

public boolean remove(Object o) {

int index = indexOf(o);
if (index != -1) {
remove(index);
return true;
}
return false;
}

public Object remove(int index) {

if (index < 0 || index >= this.size) {
throw new IndexOutOfBoundsException("Index out of
bounds: " + index);
}
Object removedElement = this.array[index];
int numMoved = this.size - index - 1;
if (numMoved > 0) {
System.arraycopy(this.array, index + 1, this.array,
index, numMoved);
}
this.array[this.size - 1] = null;
this.size--;
return removedElement;
}

public void clear() {

for (int i = 0; i < this.size; i++) {
this.array[i] = null; } this.size = 0; } }

10O
 8. Se te pide que implementes una clase en Java llamada ArraySorter que ordene un
array de enteros utilizando el algoritmo de ordenamiento "Bubble Sort". La clase
debe tener los siguientes métodos públicos:
• ArraySorter(int[] array): constructor que recibe el array de enteros a
ordenar.
• void bubbleSort(): método que ordena el array utilizando el algoritmo de
Bubble Sort.
El algoritmo de Bubble Sort funciona de la siguiente manera:
- Compara el primer elemento con el segundo. Si el primer elemento es mayor que el
segundo, intercambia los elementos.
- Compara el segundo elemento con el tercero. Si el segundo elemento es mayor que
el tercero, intercambia los elementos.
- Repite el paso anterior para los elementos restantes del array (es decir, compara el
tercer elemento con el cuarto, el cuarto con el quinto, etc.).
- Continúa repitiendo los pasos 1-3 hasta que ningún intercambio sea necesario
package org.example;

public class ArraySorter {

private int[] array;

public ArraySorter(int[] array) {

this.array = array;
}

public void bubbleSort() {

boolean swapped = true;
int n = this.array.length;

while (swapped) {
swapped = false;
for (int i = 0; i < n - 1; i++) {
if (this.array[i] > this.array[i + 1]) {
int temp = this.array[i];
this.array[i] = this.array[i + 1];
this.array[i + 1] = temp;
swapped = true;
}
}
n--;
}
}
}

101
 9. Se te pide que implementes una clase en Java llamada CardDeck que represente
una baraja de cartas. La clase debe tener los siguientes métodos públicos:
• void shuffle(): método que mezcla las cartas de la baraja.
• Card drawCard(): método que devuelve la carta en la parte superior de la baraja
y la elimina de la misma.
• void returnCard(Card card): método que devuelve una carta a la parte
inferior de la baraja.
La clase Card ya está definida y tiene los siguientes atributos:

• String suit: palo de la carta (por ejemplo, "spades", "hearts", "diamonds" o

"clubs").
• int rank: valor de la carta (del 1 al 13).
package org.example.card;

public class Card {

private String suit;
private int rank;
public static final String[] suits = {"spades", "hearts",
"diamonds", "clubs"};

public Card(String suit, int rank) {

this.suit = suit;
this.rank = rank;
}

public String getSuit() {

return suit;
}

public int getRank() {

return rank;
}

@Override
public String toString() {
return rank + " of " + suit;
}
}
ackage org.example.card;
import java.util.Random;

public class CardDeck {

private final Card[] cards;
private int topIndex;

102
 private final Random random;

public CardDeck() {
this.cards = new Card[52];
this.topIndex = 51;
this.random = new Random();

int index = 0;
for (String suit : Card.suits) {
for (int rank = 1; rank <= 13; rank++) {
cards[index] = new Card(suit, rank);
index++;
}
}
}

public void shuffle() {

for (int i = 0; i < cards.length; i++) {
int j = random.nextInt(cards.length);
swapCards(i, j);
}
topIndex = 51;
}

public Card drawCard() {

if (topIndex < 0) {
throw new IllegalStateException("No more cards in
deck");
}
Card card = cards[topIndex];
cards[topIndex] = null;
topIndex--;
return card;
}

public void returnCard(Card card) {

if (topIndex >= 51) {
throw new IllegalStateException("Card deck is full");
}
topIndex++;
cards[topIndex] = card;
}

private void swapCards(int i, int j) {

Card temp = cards[i];
cards[i] = cards[j];

103
 cards[j] = temp;
}
}

10. Se te pide que implementes un programa en Java que mantenga una lista de socios
de una sociedad y que permita la creación, modificación y eliminación de dichos
socios. Además, deberás implementar una clase ComiteGestor que actúe como
gestor de la sociedad y que permita la generación de un documento de mención de
honor para los socios que hayan cumplido con ciertos estándares.
La clase Socio tiene los siguientes atributos:

• int id: identificador único del socio.

• String nombre: nombre del socio.
• String apellidos: apellidos del socio.
• int edad: edad del socio.
• String direccion: dirección del socio.
• String telefono: número de teléfono del socio.
• String email: dirección de correo electrónico del socio.
• double cuotaMensual: cuota mensual que paga el socio.
La clase Sociedad tiene los siguientes métodos públicos:

• void crearSocio(Socio socio): método que crea un nuevo socio y lo agrega a

la lista de socios.
• void modificarSocio(Socio socio): método que modifica los datos de un
socio existente.
• void eliminarSocio(int id): método que elimina un socio de la lista de
socios.
• Socio buscarSocio(int id): método que busca un socio por su identificador
único y devuelve un objeto Socio.
• void generarMencionHonor(): método que genera un documento de mención
de honor para los socios que hayan cumplido con ciertos estándares.
La clase ComiteGestor tiene los siguientes métodos públicos:

• void establecerEstandar(double estandar): método que establece el

estándar para la mención de honor.
• double obtenerEstandar(): método que devuelve el estándar para la mención
de honor.
• void generarMencionHonor(): método que llama al método
generarMencionHonor de la clase Sociedad.

104
package org.example.sociedad;
public class Sociedad {
private Socio[] listaSocios;
private int numSocios;

public Sociedad() {
listaSocios = new Socio[100]; // Tamaño inicial del array
numSocios = 0;
}

public void crearSocio(Socio socio) {

listaSocios[numSocios] = socio;
numSocios++;
}

public void modificarSocio(Socio socioModificado) {

Socio socioAntiguo = buscarSocio(socioModificado.getId());
if (socioAntiguo != null) {
for (int i = 0; i < numSocios; i++) {
if (listaSocios[i].getId() ==
socioModificado.getId()) {
listaSocios[i] = socioModificado;
break;
}
}
}
}

public void eliminarSocio(int id) {

Socio socioAEliminar = buscarSocio(id);
if (socioAEliminar != null) {
for (int i = 0; i < numSocios; i++) {
if (listaSocios[i].getId() == id) {
// Desplaza los elementos del array para
eliminar el socio
for (int j = i; j < numSocios - 1; j++) {
listaSocios[j] = listaSocios[j + 1];
}
listaSocios[numSocios - 1] = null;
numSocios--;
break;
}
}
}
}

105
 public Socio buscarSocio(int id) {
for (int i = 0; i < numSocios; i++) {
if (listaSocios[i].getId() == id) {
return listaSocios[i];
}
}
return null;
}

public void generarMencionHonor() {

double estandar =
ComiteGestor.getInstance().obtenerEstandar();
for (int i = 0; i < numSocios; i++) {
Socio socio = listaSocios[i];
if (socio.getCuotaMensual() >= estandar) {
System.out.println("Mención de honor para el socio "
+ socio.getNombre() + " " + socio.getApellidos());
}
}
}
}
package org.example.sociedad;

public class Socio {

private int id;
private String nombre;
private String apellidos;
private int edad;
private String direccion;
private String telefono;
private String email;
private double cuotaMensual;

public Socio(int id, String nombre, String apellidos, int edad,

String direccion, String telefono, String email, double
cuotaMensual) {
this.id = id;
this.nombre = nombre;
this.apellidos = apellidos;
this.edad = edad;
this.direccion = direccion;
this.telefono = telefono;
this.email = email;
this.cuotaMensual = cuotaMensual;
}

106
public int getId() {
return id;
}

public String getNombre() {

return nombre;
}

public void setNombre(String nombre) {

this.nombre = nombre;
}

public String getApellidos() {

return apellidos;
}

public void setApellidos(String apellidos) {

this.apellidos = apellidos;
}

public int getEdad() {

return edad;
}

public void setEdad(int edad) {

this.edad = edad;
}

public String getDireccion() {

return direccion;
}

public void setDireccion(String direccion) {

this.direccion = direccion;
}

public String getTelefono() {

return telefono;
}

public void setTelefono(String telefono) {

this.telefono = telefono;
}

public String getEmail() {

return email;

107
 }

public void setEmail(String email) {

this.email = email;
}

public double getCuotaMensual() {

return cuotaMensual;
}

public void setCuotaMensual(double cuotaMensual) {

this.cuotaMensual = cuotaMensual;
}
}
package org.example.sociedad;

public class ComiteGestor {

private static ComiteGestor instance;
private double estandar;

private ComiteGestor() {
this.estandar = 0.0;
}

public static ComiteGestor getInstance() {

if (instance == null) {
instance = new ComiteGestor();
}
return instance;
}

public void establecerEstandar(double estandar) {

this.estandar = estandar;
}

public double obtenerEstandar() {

return estandar;
}

public void generarMencionHonor() {

Sociedad sociedad = new Sociedad();
sociedad.generarMencionHonor();
} }

108
 11. Supongamos que ahora se te pide que implementes un programa en Java para una
tienda online que venda productos. Cada producto tendrá un código único, nombre,
descripción, precio y cantidad disponible en inventario. Además, deberás
implementar una clase CarritoDeCompras que permita a los clientes añadir
productos a su carrito y hacer la compra final.
La clase Producto tiene los siguientes atributos:

• int codigo: código único del producto.

• String nombre: nombre del producto.
• String descripcion: descripción del producto.
• double precio: precio del producto.
• int cantidad: cantidad disponible en inventario del producto.
La clase TiendaOnline tiene los siguientes métodos públicos:

• void agregarProducto(Producto producto): método que agrega un nuevo

producto al inventario de la tienda.
• void eliminarProducto(int codigo): método que elimina un producto del
inventario de la tienda.
• Producto buscarProducto(int codigo): método que busca un producto por
su código y devuelve un objeto Producto.
• void imprimirInventario(): método que imprime en consola el inventario
actual de la tienda.

La clase CarritoDeCompras tiene los siguientes métodos públicos:

• void agregarProducto(Producto producto, int cantidad): método

que añade una cantidad determinada de un producto al carrito de compras del
cliente.
• void eliminarProducto(Producto producto, int cantidad): método
que elimina una cantidad determinada de un producto del carrito de compras del
cliente.
• double calcularTotal(): método que calcula el total de la compra en base a
los productos y cantidades en el carrito de compras.
• void imprimirCarrito(): método que imprime en consola los productos y
cantidades en el carrito de compras del cliente.
Se te pide también implementar una clase Descuento que actúe como gestor de la tienda y
permita aplicar descuentos en base a ciertos criterios. La clase Descuento tiene los
siguientes métodos públicos:

• void establecerDescuentoPorCantidad(int cantidad, double

descuento): método que establece un descuento en porcentaje para los
productos que se compren en una cantidad determinada.

109
 • void establecerDescuentoPorPrecio(double precio, double
descuento): método que establece un descuento en porcentaje para los
productos que tengan un precio superior a un valor determinado.
• double calcularDescuento(Producto producto, int cantidad):
método que calcula el descuento a aplicar a un producto en base a la cantidad que
se vaya a comprar.
• double calcularDescuento(Producto producto): método que calcula el
descuento a aplicar a un producto en base a su precio.
package org.example.tiendaonline;

public class TiendaOnline {

private Producto[] inventario;

private int cantidadProductos;

public TiendaOnline() {
this.inventario = new Producto[tamanoInventario];
this.cantidadProductos = 0;
}

public void agregarProducto(Producto producto) {

if (this.cantidadProductos < this.inventario.length) {
this.inventario[this.cantidadProductos] = producto;
this.cantidadProductos++;
} else {
System.out.println("No se pueden agregar más productos
al inventario.");
}
}

public void eliminarProducto(int codigo) {

boolean encontrado = false;
for (int i = 0; i < this.cantidadProductos; i++) {
if (this.inventario[i].getCodigo() == codigo) {
encontrado = true;
for (int j = i; j < this.cantidadProductos - 1; j++)
{
this.inventario[j] = this.inventario[j + 1];
}
this.inventario[this.cantidadProductos - 1] = null;
this.cantidadProductos--;
break;
}
}
if (!encontrado) {

10
 System.out.println("No se encontró un producto con el
código " + codigo + " en el inventario.");
}
}

public Producto buscarProducto(int codigo) {

for (int i = 0; i < this.cantidadProductos; i++) {
if (this.inventario[i].getCodigo() == codigo) {
return this.inventario[i];
}
}
return null;
}

public void imprimirInventario() {

System.out.println("Inventario de la tienda:");
for (int i = 0; i < this.cantidadProductos; i++) {
System.out.println(this.inventario[i]);
}
}

}
package org.example.tiendaonline;

public class Producto {

private int codigo;

private String nombre;
private String descripcion;
private double precio;
private int cantidad;

public Producto(int codigo, String nombre, String descripcion,

double precio, int cantidad) {
this.codigo = codigo;
this.nombre = nombre;
this.descripcion = descripcion;
this.precio = precio;
this.cantidad = cantidad;
}

public int getCodigo() {

return codigo;
}

14
 public String getNombre() {
return nombre;
}

public String getDescripcion() {

return descripcion;
}

public double getPrecio() {

return precio;
}

public int getCantidad() {

return cantidad;
}

public void setCantidad(int cantidad) {

this.cantidad = cantidad;
}

@Override
public String toString() {
return "Código: " + this.codigo + ", Nombre: " + this.nombre
+ ", Descripción: " + this.descripcion + ", Precio: $" + this.precio
+ ", Cantidad: " + this.cantidad;
}
}
package org.example.tiendaonline;

public class CarritoDeCompras {

private Producto[] productos;
private int[] cantidades;
private int cantidadProductos;

public CarritoDeCompras(int tamanoCarrito) {

this.productos = new Producto[tamanoCarrito];
this.cantidades = new int[tamanoCarrito];
this.cantidadProductos = 0;
}

public void agregarProducto(Producto producto, int cantidad) {

if (this.cantidadProductos < this.productos.length) {
// Buscamos si ya existe el producto en el carrito
int indexProducto = -1;
for (int i = 0; i < this.cantidadProductos; i++) {
if (this.productos[i].getCodigo() ==

122
producto.getCodigo()) {
indexProducto = i;
break;
}
}
// Si el producto ya existe en el carrito, sumamos la
cantidad
if (indexProducto != -1) {

this.productos[indexProducto].setCantidad(this.productos[indexProduc
to].getCantidad() + cantidad);
} else {
// Si el producto no existe en el carrito, lo
agregamos
Producto productoEnCarrito = new
Producto(producto.getCodigo(), producto.getNombre(),
producto.getDescripcion(), producto.getPrecio(), cantidad);
this.productos[this.cantidadProductos] =
productoEnCarrito;
this.cantidadProductos++;
}
} else {
System.out.println("No se pueden agregar más productos
al carrito, ha alcanzado el límite.");
}
}

public void eliminarProducto(Producto producto, int cantidad) {

// Buscamos el producto en el carrito
int indexProducto = -1;
for (int i = 0; i < this.cantidadProductos; i++) {
if (this.productos[i].getCodigo() ==
producto.getCodigo()) {
indexProducto = i;
break;
}
}

if (indexProducto != -1) {
// Si la cantidad a eliminar es mayor o igual a la
cantidad en el carrito, eliminamos el producto del carrito
if (cantidad >=
this.productos[indexProducto].getCantidad()) {
for (int i = indexProducto; i <
this.cantidadProductos - 1; i++) {
this.productos[i] = this.productos[i+1];

123
 }
this.productos[this.cantidadProductos - 1] = null;
this.cantidadProductos--;
} else {
// Si la cantidad a eliminar es menor que la
cantidad en el carrito, restamos la cantidad

this.productos[indexProducto].setCantidad(this.productos[indexProduc
to].getCantidad() - cantidad);
}
} else {
System.out.println("El producto no está en el
carrito.");
}
}

public double calcularTotal() {

double total = 0;
for (int i = 0; i < this.cantidadProductos; i++) {
total += this.productos[i].getPrecio() *
this.productos[i].getCantidad();
}
return total;
}

public void imprimirCarrito() {

System.out.println("Carrito de compras:");
for (int i = 0; i < this.cantidadProductos; i++) {
System.out.println(this.productos[i].getNombre() + " x"
+ this.productos[i].getCantidad() + " = $"
+ this.productos[i].getPrecio() *
this.productos[i].getCantidad());
}
System.out.println("Total: $" + this.calcularTotal());
}
package org.example.tiendaonline;

public class Descuento {

private int cantidadMinimaDescuento;
private double descuentoCantidad;
private double precioMinimo;
private double descuentoPrecio;
public Descuento(int cantidadMinimaDescuento, double
descuentoCantidad, double precioMinimo, double descuentoPrecio) {
this.cantidadMinimaDescuento = cantidadMinimaDescuento;
this.descuentoCantidad = descuentoCantidad;

124
 this.precioMinimo = precioMinimo;
this.descuentoPrecio = descuentoPrecio;
}
public void establecerDescuentoPorCantidad(int cantidad, double
descuento) {
this.cantidadMinimaDescuento = cantidad;
this.descuentoCantidad = descuento;
}

public void establecerDescuentoPorPrecio(double precio, double

descuento) {
this.precioMinimo = precio;
this.descuentoPrecio = descuento;
}

public double calcularDescuento(Producto producto, int cantidad)

{
double descuento = 0;
if (cantidad >= this.cantidadMinimaDescuento) {
descuento = producto.getPrecio() *
this.descuentoCantidad / 100.0;
}
return descuento;
}

public double calcularDescuento(Producto producto) {

double descuento = 0;
if (producto.getPrecio() > this.precioMinimo) {
descuento = producto.getPrecio() * this.descuentoPrecio
/ 100.0;
}
return descuento;
}
public static void main(String[] args) {
TiendaOnline tienda = new TiendaOnline();
Producto p1 = new Producto(1, "Producto 1", "Descripción del
producto 1", 10.0, 5);
Producto p2 = new Producto(2, "Producto 2", "Descripción del
producto 2", 20.0, 3);
Producto p3 = new Producto(3, "Producto 3", "Descripción del
producto 3", 30.0, 2);

tienda.agregarProducto(p1);
tienda.agregarProducto(p2);
tienda.agregarProducto(p3); } } }

125
Ejercicios
Prácticos
1. Dado el siguiente código, suponiendo que todas las clases implicadas están
correctamente implementadas y que el método obtenerFechas() devuelve un array de
tipo LocalDate de cualquier longitud, implemente (sin retocar mas líneas de las
indicadas):

(a) Un código equivalente al de las líneas 13-15, utilizando un bucle for clásico.
public class Bucles {
public LocalDate[] obtenerFechas() {
// código para obtener las fechas
}

public static void main(String[] args) {

LocalDate[] fechas = obtenerFechas();
for(int i = 0; i < fechas.length; i++) {
System.out.println("Fecha: " + fechas[i]);
}} }

(b) Un código equivalente al de las líneas 13-15, utilizando un bucle while.

LocalDate[] fechas = obtenerFechas();

int i = 0;
while (i < fechas.length) {
System.out.println("Fecha: " + fechas[i]);
i++;
}

126
MRAR ejo de Ejemplos Tipo . . . . . . . .

p. 184-108

2. A partir del diagrama UML que se le muestra a continuación, y centrándose en el

significado de los símbolos UML que se utilizan para representar elementos software,
responda a las siguientes cuestiones:

(a) ¿Como se implementaría la relación entre Socio y Estandar utilizando Java? Asume
que lato el codigo a excepción de la pregunta aquí expuesta esta implementado

(b) ¿Como se implementaría la relación entre sociedad y socio utilizando Java? Asuma que
todo el código a excepción de la pregunta aquí expuesta está implementado.

(c) Implemente en Java la relación entre Sociedad y Documento Mercantil asumiendo una
relación 1:1 y aplicando los principios de la Programación Orientada a Objetos. Asuma
que todo el código a excepción de la pregunta aqui expuesta está implementado

127
(d) Implemente el método añadir Socio gestionando los eventos no descados que
potencialmente pudiesen ocurrir, si aplica. Si necesita alguna otra modificación en el
código que no está representada en el UML, restícela como considere, en UML o
utilizando la sintaxis de Java.

128
3. Dado el sigulente códico fuente, se le solicita que explique y justifique qué
sucede en ciertas líneas concretas de la clase Test. Para cada trozo de codigo
debera responder a las siguientes preguntas:

129
• ¿Qué sucede en esas líneas de código? Justifique su respuesta.
• ¿esas lineas de codigo compilan o no compilan? Justifique sus razones.
• Si las líneas compilasen: indique y justifique la salida que se producirá al ejecutarlas.
• Si las líneas no compilan, opcionalmente puede modificarlas para que compilen.
Para justificar sus respuestas deberá hacer referencia a las características de la programación
orientada a objctos o programación en Java que aplican en cada uno de esos casos (como:
relaciones de herencia, polimorfismo, sobrescritura de métodos,

(a) Líneas 30-31:

En esta línea de código se crea un objeto de la clase abstracta FormaGeometrica y se llama al método
identidad() de la misma. Sin embargo, como la clase es abstracta, no se puede instanciar un objeto de
ella y esto generaría un error de compilación.

(b) Líneas 32-33:

En esta línea se crea un objeto de la clase Cuadrado y se asigna a la variable de tipo FormaGeometrica
'forma'. Luego se llama al método identidad() del objeto creado. Dado que Cuadrado hereda de
Rectangulo, que hereda de FormaGeometrica, se utiliza polimorfismo para llamar al método identidad()
del objeto de tipo Cuadrado. La salida sería: "Soy forma geometrica. *Y, ademas, soy rectangulo *Soy
cuadrado."

(c) Líneas 34-35:

En esta línea se crea un objeto de la clase Rectangulo y se asigna a la variable 'rectangulo'. Luego se
llama al método identidad() del objeto creado. Al llamar al método identidad() de un objeto de tipo
Rectangulo, se utiliza la implementación del método de la clase Rectangulo. La salida sería: "Soy forma
geometrica. *Y, ademas, soy rectangulo".

(d) Líneas 36-37:

En esta línea se crea un objeto de la clase Triangulo y se asigna a la variable 'triangulo'. Luego se llama
al método identidad(String s) del objeto creado. Sin embargo, el método identidad(String s) no está
definido en la clase FormaGeometrica, por lo que generaría un error de compilación.

(e) Líneas 38-41:

En estas líneas se crea un arreglo de objetos de la clase FormaGeometrica con una longitud de 2. Luego
se asigna el objeto 'forma' en la posición 0, el objeto 'rectangulo' en la posición 1 y el objeto 'triangulo'
en la posición 2. Sin embargo, el arreglo se declara con una longitud de 2 y se intenta asignar 3 objetos,
por lo que generaría un error de compilación.

(e) Líneas 38-41:

En esta línea se recorre el arreglo 'formas' con un bucle for-each y se llama al método identidad() de
cada objeto en el arreglo. Debido al polimorfismo, se llamará al método identidad() de cada objeto
correspondiente a su clase concreta. Por lo tanto, la salida sería: "Soy forma geometrica. *Y, ademas,
soy rectangulo *Soy cuadrado." para el primer objeto (de tipo Cuadrado), y "Soy forma geometrica.
*Soy triangulo. Nombre: null" para el segundo objeto (de tipo Triangulo).
130
4. Los Metabólitos son compuesto, generalmente orgánicos, que participan ea los
reacciones químicas que tienen lugar en el organismo (concretamente en aquellas
relacionadas con el metabolismo). Se desea implementar una aplicación para una
asignatura de química analítica que permita trabajar con este tipo de elementos.
Para ello, será necesaria la programación de ciertas clases que modelen dichos
datos y de un programa principal que, en un prmer momento, servirá para
comprobar la validez de dichas clases.
A lo largo del ejercicio, asegurese de que sus clases respetan el principio de
encapsula mento que reutiliza al maximo todo el código que escriba. Por otra parte,
el código debera estar correctamente estructurado en métodos.
Tenga en cuenta que, al final del enunciado. se le proporcionan métodos auxiliares
que podrás utilizar para resover el ejercicio.

En este contexto, se le solicita que:

(a) Programe la clase Metabolito y todos sus métodos asociados (tanto los
solicitados, como los auxiliares que crea necesarios para estructurar el código
correctamente). su clase deberá cumplir con los siguientes requisitos:
•La clase Metabolito deberá contener los siguientes atributos (elija el tipo más
adecuado:
- Fórmula química (por ejemplo: "C5H1207P2”) peso molecular y nombre del
compuesto (que puede ser mull si el usuario no quiere registrar el nombre).
- Tenga en cuenta que una fórmula química es una secuencia de pares (símbolo
número).
o Un simbolo es una combinación de letras mayúsculas y minúsculas con al
menos una letra que representa a un elemento químico concreto. Por
ciemplo. "Ca" renresenta el calcio o "H” el hidrógeno.
o El número de veces que aparece un elemento en la fórmula es un entero.
Por ejemplo: "Ca2” indica que el elemento calcio está dos veces en la fórmula.
o Precisamente, cuando hacemos referencia a un par (simbolo, número), nos
referimos a una cadena similar a la siguiente: "Ca2'.
o Para simplificar el problema, aunque en el mundo real no es así, la fórmula
siempre contendrá el número de veces que aparece cada elemento. Por ejemplo, la
fórmula de la molécula de agua sería representada como: H201
(contiene dos hidrógenos y un oxigeno).
o En la fórmula del ejemplo ("C5H1207P2") se puede observar la siguiente
secuencia de pares (símbolo, número): "C5", "H12", "O2” y "P2". Lo que significa
que este elemento contiene o carbonos, La hdrógenos. 7 orígenos y dos fosforos.
o A través de la fórmula se puede obtener el peso molecular del compuesto,
que es la suma de las aportaciones de todos los pares (símbolo, número). Por
ejemplo, si uno de los pares es "C5", su aportación al peso mo lecular será el
resultado de multiplicar por 5 la masa atómica del elemento “C” (carbono).

131
-La clase Metabolito deberá proporcionar los siguientes constructores:
• Un constructor que recibirá como parámetros: la fórmula del metabolito, su peso
molocular y su nombre.
• Un constructor que recibirá como parámetros la fórmula del metabolito y su peso
molecular.
• Un constructor que recibirá como parámetros solo la fórmula del metabolico y cálcule
el peso molecular.

-La clase Metabolito deberá contener los siguientes métodos y funciones:

• getters que permitan leer todos los atributos.
• setter para el atributo fórmula químico. Tenga en cuenta que, si cambia la fórmula
química, tendrá que recalcular el peso molocular y el nombre des compuesto debería
borrarse (dado que el compuesto ha cambiado).
• public static doble calculateMolecularWeight (String formula): este metodo calculara
la masa molecular del compuesto cuya formula se pasa
Dor parametro.
• La clase Metabolito tendrá un método toString que devuelva una representar ción
donde se puedan observar los valores de todos los atributos de un meta bolito human-
readable.
• La clase Metabolito tendrá un método toCSV que devuelva una representación donde
se puedan observar los valores de todos los atributos de un metabolito aplicando el
formato CSV (comma separated values).
• La clase Metabolito tendrá una función fromCSV que devuelva un objeto de tipo
Metabolito donde se reciba un String con formato CSV (comma separated values) y lo
transforme para crear el Metabolito correspondiente.

- En cualquier caso, siempre deberá asegurar la coherencia de los datos, lanzando as

excepciones que considere oportunas. Concretamente, deberá verificar que:
• La fórmula es correcta (contiene una secuencia de pares). Es decir, uno o varios
casos de simbolo de elemento seguido de su numero de apariciones.
• Que la fórmula contiene símbolos válidos de elementos químicos (es decir, símbolos
definidos en la tabla periódica).
• Que el peso molecular que le puedan pasar como parámetro, coincida realmente con el
peso molecular de la correspondiente fórmula. Utilice un valor de 0.001 como tolerancia
permitida. Utilice las propiedades de la POO para declara dicha tolerancia.

(b) Programe otra clase denominada Metabolito Primario, que es un tipo más
especializado de Metabolito. Esta nueva clase:
• Tiene los mismos atributos y métodos que la clase Metabolito.
. Posee un atributo denominado tipo que solo podrá tener los valores: LIPIDO
PROTEINA, CARBOHIDRATO.

132
• Tiene un único constructor que recibe TODOS los datos necesarios para inicializas
un MetabolitoPrimario.
• Un Método gel Tipo que devuelva el tipo de metabolito.
• Un metodo tostring que, además de la funcionalidad del método toString de la clase
Metabolito, añada el atributo tipo.
• Un metodo toCSV que, además de la funcionalidad del método toCSV de la clase
Metabolito, ariada el valor del atributo tipo.
• La clase Metacolito Primario tendrá una función fromCSV que devuelva un objeto de
tipo Metadolito Primario donde se reciba un String con formato CSV (comma separated
values) y lo transforme para crear el MetabolitoPrimorio correspondiente
Para la realización de este apartado, suponga que la clase Metabolito ha sido progra
mada satisfactoriamente

(c) Programé otra clase denominada ProgramaPrincipal que contensa un método main
que se encargue de solicitar al usuario si desea:
1. Cargar un fichero de MetabolitoPrimario.
2. Introducir un número de elementos (solicitado al usuario) de tipo MetabolitoPrimario,
los almacene en memoria y, posteriormente, los muestre por pantalla.
3. Introducir un número de elementos (solicitado al usuario) de tipo MetabolitoPrimario,
los almacene en memoria y, posteriormente los guarde en un fichero CSV.
Para la realización de este apartado, suponga que las clases Metabolito y Metabolito-
Primario han sido programadas satisfactoriamente.

Para la realización de este ejercicio:

• Suponga que tiene una clase, denominada Utils, correctamente implementada que
incluye los siguientes metodos:
• public static boolean checkChemicalSymbol (String symbol): este método
recibe una cadena de caracteres y e método devuelve cierto si esa cadena se corresponde
con un simbolo válido de la tabla periódica. Devuelve falso en caso contrario.
• public static doble getAtonichass (String symbol): este método recibe una cadena de
caracteres que representa a un simbolo químico válido y devuelve ha masa atómica de
dicho elemento. Si la cadena recibida no se corresponde con un símbolo válido en la tabla
periódica, el método lanza una excepción NonValidSymbolException.
• Suponga también que la clase Utils contiene los métodos: leerCadena, leerEntero,
leerFloat y leerDouble correctamente implementados. Utilícelos para leer por consola
como onace en os cicrcicios de clase.
• Recuerde que la clase Integer contiene un método, denominado parseint, que transforma
una cadena de caracteres en el entero que representa. Si la cadena de caracteres no
representase un número entero, ese método lanza la excepción NumberFormatReception.

133
(a) public class Metabolito {
private String formulaQuimica;
private double pesoMolecular;
private String nombreCompuesto;
private String[] elementos; // arreglo para almacenar los elementos de la formula quimica
private int[] cantidades; // arreglo para almacenar las cantidades de los elementos de la formula quimica

// Constructor que recibe como parametros la formula del metabolito, su peso molecular y su nombre
public Metabolito(String formulaQuimica, double pesoMolecular, String nombreCompuesto) throws
Exception {
this.formulaQuimica = formulaQuimica;
this.pesoMolecular = pesoMolecular;
this.nombreCompuesto = nombreCompuesto;
parseFormula(formulaQuimica); // parsear la formula y almacenar los elementos y cantidades
}

// Constructor que recibe como parametros la formula del metabolito y su peso molecular
public Metabolito(String formulaQuimica, double pesoMolecular) throws Exception {
this(formulaQuimica, pesoMolecular, null); // llamar al constructor con tres parametros y establecer el
nombre en null
}

// Constructor que recibe como parametro solo la formula del metabolico y la calcula
public Metabolito(String formulaQuimica) throws Exception {
this(formulaQuimica, calculateMolecularWeight(formulaQuimica));
}

// Getter del atributo formulaQuimica

public String getFormulaQuimica() {
return formulaQuimica;
}

// Setter del atributo formulaQuimica

public void setFormulaQuimica(String formulaQuimica) throws Exception {
if (formulaQuimica == null || formulaQuimica.isEmpty()) {
throw new Exception("La fórmula no puede ser nula o vacía.");
}

this.formulaQuimica = formulaQuimica;
this.pesoMolecular = calculateMolecularWeight(formulaQuimica); // recalcular el peso molecular
this.nombreCompuesto = null; // borrar el nombre del compuesto

parseFormula(formulaQuimica); // parsear la nueva formula y almacenar los elementos y cantidades

}

// Getter del atributo pesoMolecular

public double getPesoMolecular() {
return pesoMolecular;
}

// Getter del atributo nombreCompuesto

public String getNombreCompuesto() {
return nombreCompuesto;
}

// Setter del atributo nombreCompuesto

public void setNombreCompuesto(String nombreCompuesto) {
this.nombreCompuesto = nombreCompuesto;
}

// Metodo para calcular la masa molecular del compuesto cuya formula se pasa como parametro
public static double calculateMolecularWeight(String formula) throws Exception {
if (formula == null || formula.isEmpty()) {

}
throw new Exception("La fórmula no puede ser nula o vacía.");
134
double molecularWeight = 0.0;
String[] tokens = formula.split("(?<=\\D)(?=\\d)|(?<=\\d)(?=\\D)"); // separar la formula en
elementos y cantidades

for (int i = 0; i < tokens.length; i += 2) { // procesar los pares (element os impares)

String token = tokens[i];

int valor = Integer.parseInt(tokens[i+1]);

switch (token) {

case "SUMA":

resultado += valor;

break;

case "RESTA":

resultado -= valor;

break;

case "MULTIPLICA":

resultado *= valor;

break;

case "DIVIDE":

resultado /= valor;

break;

default:

System.out.println("Token inválido: " + token);

System.out.println("El resultado es: " + resultado);}

135
b)

public class MetabolitoPrimario extends Metabolito {

public enum Tipo { LIPIDO, PROTEINA, CARBOHIDRATO };

private Tipo tipo;

public MetabolitoPrimario(String nombre, String formulaQuimica,

double pesoMolecular, Tipo tipo) {
super(nombre, formulaQuimica, pesoMolecular);
this.tipo = tipo;
}

public Tipo getTipo() {

return tipo;
}

@Override
public String toString() {
return super.toString() + "\nTipo: " + tipo.name();
}

@Override
public String toCSV() {
return super.toCSV() + "," + tipo.name();
}

public static MetabolitoPrimario fromCSV(String csv) {

String[] tokens = csv.split(",");
if (tokens.length != 4) {
throw new IllegalArgumentException("El formato CSV es
incorrecto");
}
String nombre = tokens[0];
String formulaQuimica = tokens[1];
double pesoMolecular = Double.parseDouble(tokens[2]);
Tipo tipo = Tipo.valueOf(tokens[3]);
return new MetabolitoPrimario(nombre, formulaQuimica,
pesoMolecular, tipo);
}
}

136
 import java.io.*;
C import java.util.*;

public class ProgramaPrincipal {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.println("¿Qué desea hacer?");

System.out.println("1. Cargar un fichero de MetabolitoPrimario.");
System.out.println("2. Introducir un número de elementos de tipo MetabolitoPrimario y mostrarlos
por pantalla.");
System.out.println("3. Introducir un número de elementos de tipo MetabolitoPrimario y guardarlos en
un fichero CSV.");

int opcion = Utils.leerEntero(scanner, "Introduzca una opción: ");

switch (opcion) {
case 1:
cargarFichero();
break;
case 2:
int numElementos = Utils.leerEntero(scanner, "Introduzca el número de elementos: ");
List<MetabolitoPrimario> metabolitos = new ArrayList<>();
for (int i = 0; i < numElementos; i++) {
MetabolitoPrimario metabolito = crearMetabolito(scanner);
metabolitos.add(metabolito);
}
mostrarMetabolitos(metabolitos);
break;
case 3:
numElementos = Utils.leerEntero(scanner, "Introduzca el número de elementos: ");
metabolitos = new ArrayList<>();
for (int i = 0; i < numElementos; i++) {
MetabolitoPrimario metabolito = crearMetabolito(scanner);
metabolitos.add(metabolito);
}
guardarMetabolitos(metabolitos);
break;
default:
System.out.println("Opción no válida.");
break;
}

scanner.close();
}

private static void cargarFichero() {

Scanner scanner = new Scanner(System.in);
System.out.println("Introduzca el nombre del fichero a cargar:");
String nombreFichero = scanner.nextLine();

try (BufferedReader reader = new BufferedReader(new FileReader(nombreFichero))) {

String line;
List<MetabolitoPrimario> metabolitos = new ArrayList<>();
while ((line = reader.readLine()) != null) {
MetabolitoPrimario metabolito = MetabolitoPrimario.fromCSV(line);
metabolitos.add(metabolito);
}
mostrarMetabolitos(metabolitos);
} catch (IOException e) {
System.out.println("Error al cargar el fichero: " + e.getMessage());
}

scanner.close();
} 136
 private static MetabolitoPrimario crearMetabolito(Scanner scanner) {
String nombre = Utils.leerCadena(scanner, "Introduzca el nombre del metabolito: ");
String formula = Utils.leerCadena(scanner, "Introduzca la fórmula química del metabolito: ");
double masaMolecular = calcularMasaMolecular(formula);
String tipoMetabolito = Utils.leerCadena(scanner, "Introduzca el tipo de metabolito (LIPIDO,
PROTEINA o CARBOHIDRATO): ");
MetabolitoPrimario.Tipo tipo = MetabolitoPrimario.Tipo.valueOf(tipoMetabolito.toUpperCase());
return new MetabolitoPrimario(nombre, formula, masaMolecular, tipo);
}

private static double calcularMasaMolecular(String formula) {

double masaMolecular = 0.0;
int index = 0;
while (index < formula // Loop through each character in the formula
while (index < formula.length()) {

char c = formula.charAt(index);

// Check if the character is a letter (capital or lowercase)

if (Character.isLetter(c)) {
StringBuilder sb = new StringBuilder();
sb.append(c);
index++;

// Keep adding characters to the string builder until a non-letter character is found
while (index < formula.length() && Character.isLetter(formula.charAt(index))) {
sb.append(formula.charAt(index));
index++;
}

// Check if the chemical symbol is valid

if (!Utils.checkChemicalSymbol(sb.toString())) {
throw new NonValidSymbolException("The chemical symbol " + sb.toString() + " is not valid.");
}

// Get the atomic mass of the element and add it to the total mass
totalMass += Utils.getAtomicMass(sb.toString());
}
// Check if the character is a digit
else if (Character.isDigit(c)) {
StringBuilder sb = new StringBuilder();

// Keep adding digits to the string builder until a non-digit character is found
while (index < formula.length() && Character.isDigit(formula.charAt(index))) {
sb.append(formula.charAt(index));
index++;
}

// Multiply the total mass by the number represented by the digits

totalMass *= Integer.parseInt(sb.toString());
}
// Check if the character is an opening parenthesis
else if (c == '(') {
index++;

// Recursively calculate the mass of the contents of the parentheses and add it to the total mass
totalMass += calculateMass(formula.substring(index), 1);

137
 // Skip past the closing parenthesis
while (index < formula.length() && formula.charAt(index) != ')') {
index++;
}
index++;
}
// Check if the character is a closing parenthesis or any other non-letter or non-digit
character
else {
index++;
}

138
•