Ejercicios propuestos y resueltos programación

orientado a objetos Java

Hola a todos, hoy os dejo una serie de ejercicios de Java para practicar todo aquello que hemos
explicado en anteriores posts, haciendo hincapié en la programación orientada a objetos.

Todos los ejercicios que proponemos están resueltos en este mismo post, intenta hacerlo por ti mismo y
si te quedas atascado puedes mirar la solución. Recuerda, que no tiene por que estar igual tu solución
con la del post, el objetivo es que aprendas no que me copies la solución.

Crea un proyecto en Java por ejercicio. Colocare en las soluciones algunos comentarios para que sean
más fácilmente entendibles.

Acostúmbrate a usar Javadoc. Te recomiendo que uses mensajes de trazas, donde te sean necesarios.
Si tienes problemas también puedes usar el depurador.

Aquí tienes todos los posts relacionados con Java:

 Introduccion
 Convención de nombres
 Comentarios
 Variables primitivas
 Constantes
 Operadores
 Entrada y salida de datos
 Ámbito de una variable
 String
 Métodos String
 Casting
 Métodos Math
 Generar un número aleatorio con Math.random
 Estructura condicional
 Estructura repetitiva
 Mensajes de traza
 Pasar de String a distintos tipos de datos en Java
 Caracteres de Escape
 API Java
 Métodos Java
 Arrays en Java
 Bucles anidados
 Arrays en métodos en Java
 Referencias en Java
 Arrays multidimensionales
 Métodos java.util.Arrays Java
 Formas de ordenar un array en Java
 Introducción a la programación orientada a objetos
 Variable this
 Sobrecarga de métodos y constructores
 Método toString
 Operador instanceof
 Array de Objetos
 Comparación de objetos Java
 Clases abstractas
 Interfaces
 Uso de constantes en Java
 Métodos y atributos estáticos
 Polimorfismo Java
 Modificadores de acceso
 Clases y métodos finales
 Métodos get y set
 Herencia Java
 Como utilizar Javadoc
También incluyo los posts relacionados con eclipse.

 Como usar Eclipse Juno

 Instalar y desinstalar plugins en Eclipse
 Como traducir Eclipse a Español
Si tienes alguna duda, recuerda que puedes consultarnos escribiendo un comentario en este post o
enviándonos un e-mail a administrador@discoduroderoer.es

1) Haz una clase llamada Persona que siga las siguientes condiciones:
 Sus atributos son: nombre, edad, DNI, sexo (H hombre, M mujer), peso y altura. No queremos
que se accedan directamente a ellos. Piensa que modificador de acceso es el más adecuado,
también su tipo. Si quieres añadir algún atributo puedes hacerlo.
 Por defecto, todos los atributos menos el DNI serán valores por defecto según su tipo (0 números,
cadena vacía para String, etc.). Sexo sera hombre por defecto, usa una constante para ello.

 Se implantaran varios constructores:

o Un constructor por defecto.

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

o Un constructor con todos los atributos como parámetro.

 Los métodos que se implementaran son:

o calcularIMC(): calculara si la persona esta en su peso ideal (peso en kg/(altura^2 en m)),

devuelve un -1 si esta por debajo de su peso ideal, un 0 si esta en su peso ideal y un 1 si tiene
sobrepeso .Te recomiendo que uses constantes para devolver estos valores.
o esMayorDeEdad(): indica si es mayor de edad, devuelve un booleano.
o comprobarSexo(char sexo): comprueba que el sexo introducido es correcto. Si no es correcto,
sera H. No sera visible al exterior.
o toString(): devuelve toda la información del objeto.
 o generaDNI(): genera un numero aleatorio de 8 cifras, genera a partir de este su número su letra
correspondiente. Este método sera invocado cuando se construya el objeto. Puedes dividir el
método para que te sea más fácil. No será visible al exterior.
o 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, deberá comprobar si esta 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.

Puedes usar métodos en la clase ejecutable, para que os sea mas fácil.

Esconder «
–Clase Persona
1 /**
2 * Clase Persona
*
3 * Contiene información de una persona
4 *
5 * @author Fernando
6 * @version 1.0
7 */
public class Persona {
8
9 //Constantes
10
11 /**
12 * Sexo por defecto
13 */
14 private final static char SEXO_DEF='H';
15
/**
16 * El peso de la persona esta por debajo del peso ideal
17 */
18 public final int INFRAPESO=-1;
19
20 /**
* El peso de la persona esta en su peso ideal
21
*/
22 public final int PESO_IDEAL=0;
23
24 /**
25 * El peso de la persona esta por encima del peso ideal
26 */
27 private final int SOBREPESO=1;
28
//Atributos
29
30 /**
31 * Nombre de la persona
32 */
33 private String nombre;
34
/**
35
* Edad de la persona
36 */
37 private int edad;
38
39 /**
40 * DNI de la persona, se genera al construir el objeto
*/
41
private String DNI;
42
43 /**
44 * Sexo de la persona, H hombre M mujer
45 */
46 private char sexo;
47
/**
48
* Peso de la persona
49 */
50 private double peso;
51
52 /**
53 * Altura de la persona
*/
54
private double altura;
55
56 //Métodos privados
57
58 private void comprobarSexo(char sexo){
59
60 //Si el sexo no es una H o una M, por defecto es H
61 if(sexo!='H' && sexo!='M'){
this.sexo='H';
62 }else{
63 this.sexo=sexo;
64 }
65 }
66
67 private void generarDni(){
final int divisor=23;
68
69 //Generamos un número de 8 digitos
70 int numDNI=((int)Math.floor(Math.random()*(100000000-
10000000)+10000000));
71
int res=numDNI-(numDNI/divisor*divisor);
72
73 //Calculamos la letra del DNI
74 char letraDNI=generaLetraDNI(res);
75
76 //Pasamos el DNI a String
77 DNI=Integer.toString(numDNI)+letraDNI;
}
78
79
private char generaLetraDNI(int res){
80 char letras[]={'T', 'R', 'W', 'A', 'G', 'M', 'Y',
81 'F', 'P', 'D', 'X', 'B', 'N', 'J', 'Z',
82 'S', 'Q', 'V', 'H', 'L', 'C', 'K', 'E'};
83
84 return letras[res];
}
85
86 //Métodos publicos
87
88 /**
89 * Modifica el nombre de la persona
90 * @param nombre a cambiar
91 */
public void setNombre(String nombre) {
92 this.nombre = nombre;
93 }
94
95 /**
96 * Modifica la edad de la persona
97 * @param edad a cambiar
*/
98 public void setEdad(int edad) {
99 this.edad = edad;
100 }
101
102 /**
103 * Modifica el sexo de la persona, comprueba que es correcto
* @param sexo a cambiar
104 */
105 public void setSexo(char sexo) {
106 this.sexo = sexo;
107 }
108
109 /**
* Modifica el peso de la persona
110 * @param peso a cambiar
111 */
112 public void setPeso(double peso) {
113 this.peso = peso;
}
114
115 /**
116 * Modifica la altura de la persona
* @param altura a cambiar
117 */
118 public void setAltura(double altura) {
119 this.altura = altura;
120 }
121
/**
122
* Calcula el indice de masa corporal
123 * @return codigo numerico
124 *<ul><li>-1: la persona esta por debajo de su peso ideal</li>
125 *<li>0: la persona esta en su peso ideal</li>
126 *<li>1: la persona esta por encima de su peso ideal</li></ul>
*/
127
public int calcularIMC(){
128 //Calculamos el peso de la persona
129 double pesoActual=peso/(Math.pow(altura, 2));
130 //Segun el peso, devuelve un codigo
131 if (pesoActual>=20 && pesoActual<=25){
return PESO_IDEAL;
132
}else if(pesoActual<20){
133 return INFRAPESO;
134 }else{
135 return SOBREPESO;
136 }
}
137
/**
138 * Indica si la persona es mayor de edad
139 * @return true si es mayor de edad y false es menor de edad
140 */
141 public boolean esMayorDeEdad(){
boolean mayor=false;
142 if (edad>=18){
143 mayor=true;
144 }
145 return mayor;
146 }
147
/**
148 * Devuelve informacion del objeto
149 * @return cadena con toda la informacion
150 */
151 public String toString(){
152 String sexo="";
if(this.sexo=='H'){
153 sexo="hombre";
154 }else{
155 sexo="mujer";
156 }
157 return "Informacion de la persona:n" +
"Nombre: "+nombre+"n" +
158 "Sexo: "+sexo+"n" +
159 "Edad: "+edad+" añosn" +
"DNI: "+DNI+"n" +
160 "Peso: "+peso+" kgn" +
161 "Altura: "+altura+" metrosn";
162 }
163
164 /**
* Constructor por defecto
165
*/
166 public Persona(){
167 this("", 0, SEXO_DEF, 0, 0);
168 }
169
170 /**
* Constructor con 3 parametroe
171
* @param nombre de la persona
172 * @param edad de la persona
173 * @param sexo de la persona
174 */
175 public Persona(String nombre, int edad, char sexo){
this(nombre, edad, sexo, 0, 0);
176
}
177
178 /**
179 * Constructor con 5 parametros
180 * @param nombre de la persona
181 * @param edad de la persona
* @param sexo de la persona
182
* @param peso de la persona
183 * @param altura de la persona
184 */
185 public Persona(String nombre, int edad, char sexo, double peso, double
186 altura){
this.nombre=nombre;
187 this.edad=edad;
188 this.peso=peso;
189 this.altura=altura;
190 generarDni();
191 comprobarSexo(sexo);
}
192 }
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
–Clase ejecutable
import javax.swing.JOptionPane;
1
public class PersonaApp {
2
3 public static void main(String[] args) {
4
5 //Introducimos los datos
6 String nombre=JOptionPane.showInputDialog("Introduce el
7 nombre");
8
String texto=JOptionPane.showInputDialog("Introduce la edad");
9 int edad=Integer.parseInt(texto);
10
11 texto=JOptionPane.showInputDialog("Introduce el sexo");
12 char sexo=texto.charAt(0);
13
14 texto=JOptionPane.showInputDialog("Introduce el peso");
15 double peso=Double.parseDouble(texto);
16
texto=JOptionPane.showInputDialog("Introduce la altura");
17 double altura=Double.parseDouble(texto);
18
19 //Creamos objetos con cada constructor
20 Persona persona1=new Persona();
21 Persona persona2=new Persona(nombre, edad, sexo);
Persona persona3=new Persona(nombre, edad, sexo, peso, altura);
22
23 //Los datos que no esten completos los insertamos con los
24 metodos set
25 persona1.setNombre("Laura");
26 persona1.setEdad(30);
persona1.setSexo('M');
27
persona1.setPeso(60);
28 persona1.setAltura(1.60);
29
30 persona2.setPeso(90.5);
31 persona2.setAltura(1.80);
32
33 //Usamos metodos para realizar la misma accion para cada objeto
System.out.println("Persona1");
34 MuestraMensajePeso(persona1);
35 MuestraMayorDeEdad(persona1);
36 MuestraInformacion(persona1);
37
38 System.out.println("Persona2");
39 MuestraMensajePeso(persona2);
MuestraMayorDeEdad(persona2);
40 MuestraInformacion(persona2);
41
42 System.out.println("Persona3");
43 MuestraMensajePeso(persona3);
44 MuestraMayorDeEdad(persona3);
45 MuestraInformacion(persona3);
}
46
47 public static void MuestraMensajePeso(Persona p){
48 int IMC=p.calcularIMC();
49 if(IMC==p.PESO_IDEAL){
50 System.out.println("La persona esta en su peso ideal");
51 }else if (IMC==p.INFRAPESO){
System.out.println("La persona esta por debajo de su peso
52 ideal");
53 }else{
54 System.out.println("La persona esta por encima de su peso
55 ideal");
}
56 }
57
58 public static void MuestraMayorDeEdad(Persona p){
59 boolean mayor=p.esMayorDeEdad();
60 if(mayor){
61 System.out.println("La persona es mayor de edad");
}else{
62 System.out.println("La persona no es mayor de edad");
63 }
64 }
65
66 public static void MuestraInformacion(Persona p){
//Invoca el metodo toString
67 System.out.println(p);
68 }
69
70 }
71
72
73
74
75
76
77
78
2) Haz una clase llamada Password que siga las siguientes condiciones:
 Que tenga los atributos longitud y contraseña . Por defecto, la longitud sera de 8.
 Los constructores serán los siguiente:
o Un constructor por defecto.

 Un constructor con la longitud que nosotros le pasemos. Generara una contraseña aleatoria con esa
longitud.

 Los métodos que implementa serán:

o esFuerte(): devuelve un booleano si es fuerte o no, para que sea fuerte debe tener mas de 2
mayúsculas, mas de 1 minúscula y mas de 5 números.
o generarPassword(): genera la contraseña del objeto con la longitud que tenga.
o Método get para contraseña y longitud.

o Método set para longitud.

Ahora, crea una clase clase ejecutable:

 Crea un array de Passwords con el tamaño que tu le indiques por teclado.

 Crea un bucle que cree un objeto para cada posición del array.

 Indica también por teclado la longitud de los Passwords (antes de bucle).

 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

…
Esconder «
–Clase Password
1 /**
* Clase Password
2
*
3 * Contiene una contraseña y una longitud
4 *
5 * @author Fernando
6 * @version 1.0
*/
7
public class Password {
8
9 //Constantes
10
11 /**
12 * Longitud por defecto
13 */
private final static int LONG_DEF=8;
14
15
//Atributos
16
17 /**
18 * Longitud de la contraseña
19 */
20 private int longitud;
/**
21
* caracteres de la contraseña
22 */
23 private String contraseña;
24
25 //Metodos publicos
26
27 /**
* Devuelve la longitud
28 * @return longitud de la contraseña
29 */
30 public int getLongitud() {
31 return longitud;
32 }
33
/**
34 * Modifica la longitud de la contraseña
35 * @param longitud a cambiar
36 */
37 public void setLongitud(int longitud) {
38 this.longitud = longitud;
}
39
40 /**
41 * Devuelve la contraseña
42 * @return contraseña
43 */
44 public String getContraseña() {
return contraseña;
45 }
46
47 /**
48 * Genera una contraseña al azar con la longitud que este definida
49 * @return contraseña
*/
50
public String generaPassword (){
51 String password="";
52 for (int i=0;i<longitud;i++){
53 //Generamos un numero aleatorio, segun este elige si añadir una minuscu
54 o numero
int eleccion=((int)Math.floor(Math.random()*3+1));
55
56 if (eleccion==1){
57 char minusculas=(char)((int)Math.floor(Math.random()*(123-97)+97));
58 password+=minusculas;
59 }else{
60 if(eleccion==2){
char mayusculas=(char)((int)Math.floor(Math.random()*(91-65)+65
61 password+=mayusculas;
62 }else{
63 char numeros=(char)((int)Math.floor(Math.random()*(58-48)+48));
64 password+=numeros;
65 }
}
66 }
67 return password;
68 }
69
70 /**
71 * Comprueba la fortaleza de la contraseña
* @return
72 */
73 public boolean esFuerte(){
74 int cuentanumeros=0;
75 int cuentaminusculas=0;
76 int cuentamayusculas=0;
//Vamos caracter a caracter y comprobamos que tipo de caracter es
77 for (int i=0;i<contraseña.length();i++){
78 if (contraseña.charAt(i)>=97 && contraseña.charAt(i)<=122){
79 cuentaminusculas+=1;
80 }else{
if (contraseña.charAt(i)>=65 && contraseña.charAt(i)<=90){
81
cuentamayusculas+=1;
82 }else{
83 cuentanumeros+=1;
84 }
85 }
}
86
//Si la constraseña tiene mas de 5 numeros, mas de 1 minuscula y mas de
87 if (cuentanumeros>=5 && cuentaminusculas>=1 && cuentamayusculas>=2){
88 return true;
}else{
89 return false;
90 }
91 }
92
93 //Constructores
94
/**
95
* Crea una contraseña al azar
96 */
97 public Password (){
98 this(LONG_DEF);
99 }
100
/**
101
* La contraseña sera la pasada por parametro
102 * @param password
103 */
104 public Password (int longitud){
105 this.longitud=longitud;
contraseña=generaPassword();
106
}
107 }
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
–Clase ejecutable
import javax.swing.JOptionPane;
1
public class PasswordApp {
2
3 public static void main(String[] args) {
4
5 //Introducimos el tamaño del array y la longitud del password
6 String texto=JOptionPane.showInputDialog("Introduce un tamaño para el
array");
7 int tamanio=Integer.parseInt(texto);
8
9 texto=JOptionPane.showInputDialog("Introduce la longitud del password");
10 int longitud=Integer.parseInt(texto);
11
12 //Creamos los arrays
Password listaPassword[]=new Password[tamanio];
13
boolean fortalezaPassword[]=new boolean[tamanio];
14
15 //Creamos objetos, indicamos si es fuerte y mostramos la contraseña y su
16 fortaleza.
17 for(int i=0;i<listaPassword.length;i++){
18 listaPassword[i]=new Password(longitud);
fortalezaPassword[i]=listaPassword[i].esFuerte();
19 System.out.println(listaPassword[i].getContraseña()+"
20 "+fortalezaPassword[i]);
21 }
22 }
23
}
24
25
3) Crearemos una supeclase llamada Electrodomestico con las siguientes características:
 Sus atributos son precio base, color, consumo energético (letras entre A y F) y peso. Indica que
se podrán heredar.
 Por defecto, el color sera blanco, el consumo energético sera F, el precioBase es de 100 € y el peso
de 5 kg. Usa constantes para ello.

 Los colores disponibles son blanco, negro, rojo, azul y gris. No importa si el nombre esta en
mayúsculas o en minúsculas.

 Los constructores que se implementaran serán

o Un constructor por defecto.

o Un constructor con el precio y peso. El resto por defecto.

o Un constructor con todos los atributos.

 Los métodos que implementara serán:

o Métodos get de todos los atributos.

o comprobarConsumoEnergetico(char letra): comprueba que la letra es correcta, sino es

correcta usara la letra por defecto. Se invocara al crear el objeto y no sera visible.
o comprobarColor(String color): comprueba que el color es correcto, sino lo es usa el color por
defecto. Se invocara al crear el objeto y no sera visible.
o precioFinal(): según el consumo energético, aumentara su precio, y según su tamaño, también.
Esta es la lista de precios:
Letra Precio
 Letra Precio

A 100 €

B 80 €

C 60 €

D 50 €

E 30 €

F 10 €

Tamaño Precio

Entre 0 y 19 kg 10 €

Entre 20 y 49 kg 50 €

Entre 50 y 79 kg 80 €

Mayor que 80 kg 100 €

Crearemos una subclase llamada Lavadora con las siguientes características:

 Su atributo es carga, ademas de los atributos heredados.
 Por defecto, la carga es de 5 kg. Usa una constante para ello.
 Los constructores que se implementaran serán:

o Un constructor por defecto.

o Un constructor con el precio y peso. El resto por defecto.

o Un constructor con la carga y el resto de atributos heredados. Recuerda que debes llamar al
constructor de la clase padre.

 Los métodos que se implementara serán:

o Método get de carga.

o precioFinal():, si tiene una carga mayor de 30 kg, aumentara el precio 50 €, sino es así no se
incrementara el precio. Llama al método padre y añade el código necesario. Recuerda que las
condiciones que hemos visto en la clase Electrodomestico también deben afectar al precio.
Crearemos una subclase llamada Television con las siguientes características:
 Sus atributos son resolución (en pulgadas) y sintonizador TDT (booleano), ademas de los
atributos heredados.
 Por defecto, la resolución sera de 20 pulgadas y el sintonizador sera false.
 Los constructores que se implementaran serán:

o Un constructor por defecto.

o Un constructor con el precio y peso. El resto por defecto.

o Un constructor con la resolución, sintonizador TDT y el resto de atributos heredados. Recuerda

que debes llamar al constructor de la clase padre.

 Los métodos que se implementara serán:

o Método get de resolución y sintonizador TDT.

 o precioFinal(): si tiene una resolución mayor de 40 pulgadas, se incrementara el precio un 30%
y si tiene un sintonizador TDT incorporado, aumentara 50 €. Recuerda que las condiciones que
hemos visto en la clase Electrodomestico también deben afectar al precio.
Ahora crea una clase ejecutable que realice lo siguiente:

 Crea un array de Electrodomesticos de 10 posiciones.

 Asigna a cada posición un objeto de las clases anteriores con los valores que desees.

 Ahora, recorre este array y ejecuta el método precioFinal().

 Deberás mostrar el precio de cada clase, es decir, el precio de todas las televisiones por un lado, el
de las lavadoras por otro y la suma de los Electrodomesticos (puedes crear objetos
Electrodomestico, pero recuerda que Television y Lavadora también son electrodomésticos).
Recuerda el uso operador instanceof.

Por ejemplo, si tenemos un Electrodomestico con un precio final de 300, una lavadora de 200 y una
televisión de 500, el resultado final sera de 1000 (300+200+500) para electrodomésticos, 200 para
lavadora y 500 para televisión.

Esconder «
–Clase Electrodomestico
1 /**
2 * Clase Electrodomestico
*
3
* Contiene informacion de los electrodomesticos
4 * @author Fernando
5 * @version 1.0
6 */
7 public class Electrodomestico {
8
//Constantes
9
10
/**
11 * Color por defecto
12 */
13 protected final static String COLOR_DEF="blanco";
14
15 /**
* Consumo energetico por defecto
16 */
17 protected final static char CONSUMO_ENERGETICO_DEF='F';
18
19 /**
20 * Precio base por defecto
21 */
protected final static double PRECIO_BASE_DEF=100;
22
23 /**
24 * Peso por defecto
25 */
26 protected final static double PESO_DEF=5;
27
28 //Atributos
29
30 /**
* El precio base del electrodomestico
31 */
32 protected double precioBase;
33
34 /**
35 * Color del electrodomestico
*/
36
protected String color;
37
38 /**
39 * Indica el consumo energetico del electrodomestico
40 */
41 protected char consumoEnergetico;
42
/**
43
* Peso del electrodomestico
44 */
45 protected double peso;
46
47 //Métodos privados
48
49 private void comprobarColor(String color){
50
//Colores disponibles
51
String colores[]={"blanco", "negro", "rojo", "azul", "gris"};
52 boolean encontrado=false;
53
54 for(int i=0;i<colores.length && !encontrado;i++){
55
56 if(colores[i].equals(color)){
57 encontrado=true;
}
58
59
}
60
61 if(encontrado){
62 this.color=color;
63 }else{
64 this.color=COLOR_DEF;
}
65
66 }
67
68 /**
69 * Comprueba el consumo energetico
70 * Solo mayusculas, si es una 'a' no lo detecta como una 'A'
71 * @param consumoEnergetico
72 */
public void comprobarConsumoEnergetico(char consumoEnergetico){
73
74 if(consumoEnergetico>=65 && consumoEnergetico<=70){
75 this.consumoEnergetico=consumoEnergetico;
76 }else{
77 this.consumoEnergetico=CONSUMO_ENERGETICO_DEF;
}
78
79
}
80
81 //Métodos publicos
82 /**
83 * Devuelve el precio base del electrodomestico
84 * @return precio base del electrodomestico
*/
85
public double getPrecioBase() {
86 return precioBase;
87 }
88 /**
89 * Devuelve el color del electrodomestico
* @return color del elesctrodomestico
90
*/
91 public String getColor() {
92 return color;
93 }
94
95 /**
* Devuelve el consumo energetico del electrodomestico
96
* @return consumo energetico del electrodomestico
97 */
98 public char getConsumoEnergetico() {
99 return consumoEnergetico;
100 }
/**
101 * Devuelve el peso del electrodomestico
102 * @return peso del electrodomestico
103 */
104 public double getPeso() {
105 return peso;
}
106 /**
107 * Precio final del electrodomestico
108 * @return precio final del electrodomestico
109 */
110 public double precioFinal(){
double plus=0;
111 switch(consumoEnergetico){
112 case 'A':
113 plus+=100;
114 break;
case 'B':
115 plus+=80;
116 break;
case 'C':
117 plus+=60;
118 break;
119 case 'D':
120 plus+=50;
break;
121
case 'E':
122 plus+=30;
123 break;
124 case 'F':
125 plus+=10;
break;
126
}
127
128 if(peso>=0 && peso<19){
129 plus+=10;
130 }else if(peso>=20 && peso<49){
131 plus+=50;
}else if(peso>=50 && peso<=79){
132
plus+=80;
133 }else if(peso>=80){
134 plus+=100;
135 }
136
137 return precioBase+plus;
}
138
139
//Constructores
140
141 /**
142 * Contructor por defecto
143 */
144 public Electrodomestico(){
this(PRECIO_BASE_DEF, PESO_DEF, CONSUMO_ENERGETICO_DEF, COLOR_DEF);
145 }
146
147 /**
148 * Contructor con 2 parametros
149 * @param precioBase del electrodomestico
150 * @param peso del electrodomestico
*/
151 public Electrodomestico(double precioBase, double peso){
152 this(precioBase, peso, CONSUMO_ENERGETICO_DEF, COLOR_DEF);
153 }
154
155 /**
156 * Constructor con 4 parametros
* @param precioBase
157 * @param peso
158 * @param consumoEnergetico
159 * @param color
160 */
public Electrodomestico(double precioBase, double peso, char consumoEnergetico, S
161 color){
162 this.precioBase=precioBase;
163 this.peso=peso;
164 comprobarConsumoEnergetico(consumoEnergetico);
comprobarColor(color);
165
}
166
167 }
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
–Clase Lavadora
1 /**
2 * Clase Lavadora
*
3
* Contiene informacion de lavador
4 *
5 * @author Fernando
6 * @version 1.0
7 */
8 public class Lavadora extends Electrodomestico{
9
//Constantes
10
11 /**
12 * Carga por defecto
13 */
14 private final static int CARGA_DEF=5;
15
//Atributos
16
17
/**
18 * Carga de la lavadora
19 */
20 private int carga;
21
22 //Métodos publicos
23
/**
24
* Devuelve la carga de la lavadora
25 * @return
26 */
27 public int getCarga() {
28 return carga;
}
29
30
/**
31 * Precio final de la lavadora
32 * @return precio final de la lavadora
33 */
34 public double precioFinal(){
//Invocamos el método precioFinal del método padre
35
double plus=super.precioFinal();
36
37 //añadimos el código necesario
38 if (carga>30){
39 plus+=50;
40 }
41
return plus;
42 }
43
44 //Constructor
45
46 /**
47 * Contructor por defecto
48 */
public Lavadora(){
49 this(PRECIO_BASE_DEF, PESO_DEF, CONSUMO_ENERGETICO_DEF, COLOR_DEF, CARGA_DEF
50 }
51
52 /**
53 * Constructor con 2 parametros
* @param precioBase
54 * @param peso
55 */
56 public Lavadora(double precioBase, double peso){
57 this(precioBase, peso, CONSUMO_ENERGETICO_DEF, COLOR_DEF, CARGA_DEF);
}
58
59
/**
60 * Constructor con 5 parametros
61 * @param precioBase
62 * @param peso
63 * @param consumoEnergetico
* @param color
64
* @param carga
65 */
66 public Lavadora(double precioBase, double peso, char consumoEnergetico, String col
67 carga){
68 super(precioBase,peso, consumoEnergetico,color);
this.carga=carga;
69 }
70 }
71
72
73
74
75
76
77
78
79
80
81
–Clase Television
1 /**
2 * Clase Television
*
3 * Contiene informacion de una television
4 *
5 * @author Fernando
6 * @version 1.0
7 */
public class Television extends Electrodomestico{
8
9 //Constantes
10
11 /**
12 * Resolucion por defecto
13 */
14 private final static int RESOLUCION_DEF=20;
15
//Atributos
16
17 /**
18 * Resolucion del televisor
19 */
20 private int resolucion;
21
/**
22
* Indica si tiene o no sintonizadorTDT
23 */
24 private boolean sintonizadorTDT;
25
26 //Métodos publicos
27
28 /**
* Precio final de la television
29
* @return precio final de la television
30 */
31 public double precioFinal(){
32 //Invocamos el método precioFinal del método padre
33 double plus=super.precioFinal();
34
//Añadimos el codigo necesario
35
if (resolucion>40){
36 plus+=precioBase*0.3;
37 }
38 if (sintonizadorTDT){
39 plus+=50;
}
40
41
return plus;
42 }
43
44 //Constructor
45
46 /**
47 * Constructor por defecto
*/
48 public Television(){
49 this(PRECIO_BASE_DEF, PESO_DEF, CONSUMO_ENERGETICO_DEF, COLOR_DEF, RESOLUCIO
50 }
51
52 /**
53 * Constructor con 2 parametros
* @param precioBase
54 * @param peso
55 */
56 public Television(double precioBase, double peso){
57 this(precioBase, peso, CONSUMO_ENERGETICO_DEF, COLOR_DEF, RESOLUCION_DEF, fa
58 }
59
/**
60 * Contructor con 6 parametros
61 * @param precioBase
62 * @param peso
63 * @param consumoEnergetico
* @param color
64
* @param resolucion
65 * @param sintonizadorTDT
66 */
67 public Television(double precioBase, double peso, char consumoEnergetico, String c
68 sintonizadorTDT){
super(precioBase, peso, consumoEnergetico, color);
69 this.resolucion=resolucion;
70 this.sintonizadorTDT=sintonizadorTDT;
71 }
72 }
73
74
75
76
77
78
79
80
81
82
83
–Clase Ejecutable
1 public static void main(String[] args) {
2
//Creamos un array de Electrodomesticos
3 Electrodomestico listaElectrodomesticos[]=new Electrodomestico[10];
4
5 //Asignamos cada una de las posiciones como queramos
6 listaElectrodomesticos[0]=new Electrodomestico(200, 60, 'C', "Verde");
7 listaElectrodomesticos[1]=new Lavadora(150, 30);
8 listaElectrodomesticos[2]=new Television(500, 80, 'E', "negro", 42, false);
listaElectrodomesticos[3]=new Electrodomestico();
9 listaElectrodomesticos[4]=new Electrodomestico(600, 20, 'D', "gris");
10 listaElectrodomesticos[5]=new Lavadora(300, 40, 'Z', "blanco", 40);
11 listaElectrodomesticos[6]=new Television(250, 70);
12 listaElectrodomesticos[7]=new Lavadora(400, 100, 'A', "verde", 15);
listaElectrodomesticos[8]=new Television(200, 60, 'C', "naranja", 30, true);
13
listaElectrodomesticos[9]=new Electrodomestico(50, 10);
14
15 //Creamos las variables que usaremos para almacenar la suma de los precios
16 double sumaElectrodomesticos=0;
17 double sumaTelevisiones=0;
18 double sumaLavadoras=0;
19
//Recorremos el array invocando el metodo precioFinal
20 for(int i=0;i<listaElectrodomesticos.length;i++){
21 /*
22 * Cunado una Television o una Lavadora este en la posicion del array ac
23 * pasara por su clase y por la de electrodomestico, ya que una televisi
electrodomestico.
24
* Ejecutamos en cada uno su propia version del metodo precioFinal
25 */
26
27 if(listaElectrodomesticos[i] instanceof Electrodomestico){
28 sumaElectrodomesticos+=listaElectrodomesticos[i].precioFinal();
29 }
if(listaElectrodomesticos[i] instanceof Lavadora){
30 sumaLavadoras+=listaElectrodomesticos[i].precioFinal();
31 }
32 if(listaElectrodomesticos[i] instanceof Television){
33 sumaTelevisiones+=listaElectrodomesticos[i].precioFinal();
34 }
}
35
36 //Mostramos los resultados
37 System.out.println("La suma del precio de los electrodomesticos es de
38 "+sumaElectrodomesticos);
39 System.out.println("La suma del precio de las lavadoras es de "+sumaLavadora
System.out.println("La suma del precio de las televisiones es de "+sumaTelev
40
41
}
42
43 }
44
45
46
47
48
49
4) Crearemos una clase llamada Serie con las siguientes características:
 Sus atributos son titulo, numero de temporadas, entregado, genero y creador.
 Por defecto, el numero de temporadas es de 3 temporadas y entregado false. El resto de atributos
serán valores por defecto según el tipo del atributo.
 Los constructores que se implementaran serán:
o Un constructor por defecto.

o Un constructor con el titulo y creador. El resto por defecto.

o Un constructor con todos los atributos, excepto de entregado.

 Los métodos que se implementara serán:

o Métodos get de todos los atributos, excepto de entregado.

 o Métodos set de todos los atributos, excepto de entregado.

o Sobrescribe los métodos toString.

Crearemos una clase Videojuego con las siguientes características:

 Sus atributos son titulo, horas estimadas, entregado, genero y compañia.
 Por defecto, las horas estimadas serán de 10 horas y entregado false. El resto de atributos serán
valores por defecto según el tipo del atributo.

 Los constructores que se implementaran serán:

o Un constructor por defecto.

o Un constructor con el titulo y horas estimadas. El resto por defecto.

o Un constructor con todos los atributos, excepto de entregado.

 Los métodos que se implementara serán:

o Métodos get de todos los atributos, excepto de entregado.

o Métodos set de todos los atributos, excepto de entregado.

o Sobrescribe los métodos toString.

Como vemos, en principio, las clases anteriores no son padre-hija, pero si tienen en común, por eso
vamos a hacer una interfaz llamada Entregable con los siguientes métodos:
 entregar(): cambia el atributo prestado a true.
 devolver(): cambia el atributo prestado a false.
 isEntregado(): devuelve el estado del atributo prestado.
 Método compareTo (Object a), compara las horas estimadas en los videojuegos y en las series el
numero de temporadas. Como parámetro que tenga un objeto, no es necesario que implementes la
interfaz Comparable. Recuerda el uso de los casting de objetos.
Implementa los anteriores métodos en las clases Videojuego y Serie. Ahora crea una aplicación
ejecutable y realiza lo siguiente:

 Crea dos arrays, uno de Series y otro de Videojuegos, de 5 posiciones cada uno.
 Crea un objeto en cada posición del array, con los valores que desees, puedes usar distintos
constructores.

 Entrega algunos Videojuegos y Series con el método entregar().

 Cuenta cuantos Series y Videojuegos hay entregados. Al contarlos, devuélvelos.
 Por último, indica el Videojuego tiene más horas estimadas y la serie con mas temporadas.
Muestralos en pantalla con toda su información (usa el método toString()).
Esconder «
–Clase Serie
1 /**
2 * Clase Serie
3 *
* Contiene informacion sobre una serie (en general)
4 * @author Fernando
5 * @version 1.0
6 *
7 */
8 public class Serie implements Entregable{
9
10 //Constantes
11
/**
12 * Numero de temporadas por defecto
13 */
14 private final static int NUM_TEMPORADAS_DEF=3;
15
16 /**
* Constante que indica que un objeto es mayor que otro
17
*/
18 public final static int MAYOR=1;
19
20 /**
21 * Constante que indica que un objeto es menor que otro
22 */
public final static int MENOR=-1;
23
24
/**
25 * Constante que indica que un objeto es igual que otro
26 */
27 public final static int IGUAL=0;
28
29 //Atributos
30
/**
31
* Titulo de la serie
32 */
33 private String titulo;
34
35 /**
36 * Numero de temporadas de la serie
*/
37
private int numeroTemporadas;
38
39 /**
40 * Indica si esta entregado la serie
41 */
42 private boolean entregado;
43
/**
44 * Genero de la serie
45 */
46 private String genero;
47
48 /**
49 * Creador de la serie
*/
50 private String creador;
51
52 //Métodos publicos
53
54 /**
* Devuelve el titulo de la serie
55 * @return titulo de la serie
56 */
57 public String getTitulo() {
58 return titulo;
}
59
60
/**
61 * Modifica el titulo de la serie
62 * @param titulo a cambiar
63 */
64 public void setTitulo(String titulo) {
this.titulo = titulo;
65
}
66
67 /**
68 * Devuelve la numeroTemporadas de la serie
69 * @return numeroTemporadas de la serie
70 */
public int getnumeroTemporadas() {
71
return numeroTemporadas;
72 }
73
74 /**
75 * Modifica la numeroTemporadas de la serie
76 * @param numeroTemporadas a cambiar
*/
77
public void setnumeroTemporadas(int numeroTemporadas) {
78 this.numeroTemporadas = numeroTemporadas;
79 }
80
81 /**
82 * Devuelve el genero de la serie
* @return genero de la serie
83 */
84 public String getGenero() {
85 return genero;
86 }
87
88 /**
* Modifica el genero de la serie
89 * @param genero a cambiar
90 */
91 public void setGenero(String genero) {
92 this.genero = genero;
93 }
94
/**
95 * Devuelve el creador de la serie
96 * @return creador de la serie
97 */
public String getcreador() {
98 return creador;
99 }
100
101 /**
102 * Modifica el creador de la serie
* @param creador a cambiar
103
*/
104 public void setcreador(String creador) {
105 this.creador = creador;
106 }
107
108 /**
* Cambia el estado de entregado a true
109
*/
110 public void entregar() {
111 entregado=true;
112 }
113
114 /**
* Cambia el estado de entregado a false
115
*/
116 public void devolver() {
117 entregado=false;
118 }
119
120 /**
* Indica el estado de entregado
121
*/
122 public boolean isEntregado() {
123 if(entregado){
124 return true;
125 }
return false;
126 }
127
128 /**
129 * Compara dos series segun su numero de temporadas
130 * @param objeto a comparar
131 * @return codigo numerico
* <ul>
132 * <li>1: La Serie 1 es mayor que la Serie 2</li>
133 * <li>0: Las Series son iguales</li>
134 * <li>-1: La Serie 1 es menor que la Serie 2</li></ul>
135 */
136 public int compareTo(Object a) {
int estado=MENOR;
137
138 //Hacemos un casting de objetos para usar el metodo get
139 Serie ref=(Serie)a;
140 if (numeroTemporadas>ref.getnumeroTemporadas()){
141 estado=MAYOR;
}else if(numeroTemporadas==ref.getnumeroTemporadas()){
142 estado=IGUAL;
143 }
144
145 return estado;
146 }
147
/**
148
* Muestra informacion de la Serie
149 * @return cadena con toda la informacion de la Serie
150 */
151 public String toString(){
152 return "Informacion de la Serie: n" +
"tTitulo: "+titulo+"n" +
153
"tNumero de temporadas: "+numeroTemporadas+"n" +
154 "tGenero: "+genero+"n" +
155 "tCreador: "+creador;
156 }
157
158 /**
* Indica si dos Series son iguales, siendo el titulo y creador iguales
159
* @param a Serie a comparar
160 * @return true si son iguales y false si son distintos
161 */
162 public boolean equals(Serie a){
163 if (titulo.equalsIgnoreCase(a.getTitulo()) &&
creador.equalsIgnoreCase(a.getcreador())){
164 return true;
165 }
166 return false;
167 }
168
169 //Constructor
170
/**
171 * Constructor por defecto
172 */
173 public Serie(){
174 this("",NUM_TEMPORADAS_DEF, "", "");
175 }
176
/**
177 * Contructor con 2 parametros
178 * @param titulo de la Serie
179 * @param creador de la Serie
180 */
public Serie(String titulo, String creador){
181
this(titulo,NUM_TEMPORADAS_DEF, "", creador);
182 }
183
184 /**
185 * Constructor con 4 parametros
* @param titulo de la Serie
186 * @param numeroTemporadas de la Serie
187 * @param genero de la Serie
188 * @param creador de la Serie
189 */
public Serie(String titulo, int numeroTemporadas, String genero, String creador)
190
this.titulo=titulo;
191 this.numeroTemporadas=numeroTemporadas;
192 this.genero=genero;
193 this.creador=creador;
194 this.entregado=false;
}
195
196
}
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
–Clase Videojuego
/**
1 *
2 * Clase videojuego
3 *
4 * Contiene la informacion sobre un videojuego
5 *
* @author Fernando
6 * @version 1.0
7 */
8 public class Videojuego implements Entregable{
9
10 //Constantes
11
12 /**
* Horas estimadas por defecto
13 */
14 private final static int HORAS_ESTIMADAS_DEF=100;
15
16 /**
17 * Constante que indica que un objeto es mayor que otro
18 */
public final static int MAYOR=1;
19
20 /**
21 * Constante que indica que un objeto es menor que otro
22 */
23 public final static int MENOR=-1;
24
/**
25
* Constante que indica que un objeto es igual que otro
26 */
27 public final static int IGUAL=0;
28
29 //Atributos
30
31 /**
* Titulo del videojuego
32
*/
33 private String titulo;
34
35 /**
36 * Horas estimadas del videojuego
37 */
private int horasEstimadas;
38
39
/**
40 * Indica si esta o no entregado el videojuego
41 */
42 private boolean entregado;
43
/**
44 * Genero del videojuego
45 */
46 private String genero;
47
48 /**
* Compañia del videojuego
49
*/
50 private String compañia;
51
52 //Métodos publicos
53
54 /**
55 * Devuelve el titulo del videojuego
* @return titulo del videojuego
56
*/
57 public String getTitulo() {
58 return titulo;
59 }
60
61 /**
* Modifica el titulo del videojuego
62
* @param titulo a cambiar
63 */
64 public void setTitulo(String titulo) {
65 this.titulo = titulo;
66 }
67
/**
68
* Devuelve el numero de paginas del videojuego
69 * @return numero de paginas del videojuego
70 */
71 public int getHorasEstimadas() {
72 return horasEstimadas;
}
73
74 /**
75 * Modifica el numero de paginas del videojuego
76 * @param numero de paginas a cambiar
77 */
78 public void setHorasEstimadas(int horasEstimadas) {
this.horasEstimadas = horasEstimadas;
79 }
80
81 /**
82 * Devuelve el genero del videojuego
83 * @return genero del videojuego
84 */
public String getGenero() {
85 return genero;
86 }
87
/**
88 * Modifica el genero del videojuego
89 * @param genero a cambiar
90 */
91 public void setGenero(String genero) {
this.genero = genero;
92
}
93
94 /**
95 * Devuelve el compañia del videojuego
96 * @return compañia del videojuego
97 */
public String getcompañia() {
98
return compañia;
99 }
100
101 /**
102 * Modifica el compañia del videojuego
103 * @param compañia a cambiar
*/
104
public void setcompañia(String compañia) {
105 this.compañia = compañia;
106 }
107
108 /**
109 * Cambia el estado de entregado a true
*/
110
public void entregar() {
111 entregado=true;
112 }
113
114 /**
115 * Cambia el estado de entregado a false
*/
116 public void devolver() {
117 entregado=false;
118 }
119
120 /**
121 * Indica el estado de entregado
*/
122 public boolean isEntregado() {
123 if(entregado){
124 return true;
125 }
126 return false;
}
127
128 /**
129 * Compara dos videojuegos segun el numero de paginas
130 * @param objeto a comparar
* @return codigo numerico
131 * <ul>
132 * <li>1: El videojuego 1 es mayor que el videojuego 2</li>
133 * <li>0: Los videojuegos son iguales</li>
134 * <li>-1: El videojuego 1 es menor que el videojuego 2</li></ul>
*/
135
public int compareTo(Object a) {
136 int estado=MENOR;
137
138 //Hacemos un casting de objetos para usar el metodo get
139 Videojuego ref=(Videojuego)a;
140 if (horasEstimadas>ref.getHorasEstimadas()){
estado=MAYOR;
141
}else if(horasEstimadas==ref.getHorasEstimadas()){
142 estado=IGUAL;
143 }
144
145 return estado;
146 }
147
/**
148
* Muestra informacion del videojuego
149 * @return cadena con toda la informacion del videojuego
150 */
151 public String toString(){
152 return "Informacion del videojuego: n" +
"tTitulo: "+titulo+"n" +
153
"tHoras estimadas: "+horasEstimadas+"n" +
154 "tGenero: "+genero+"n" +
155 "tcompañia: "+compañia;
156 }
157
158 /**
* Indica si dos videojuegos son iguales, siendo el titulo y compañia iguales
159 * @param a videojuego a comparar
160 * @return true si son iguales y false si son distintos
161 */
162 public boolean equals(Videojuego a){
163 if (titulo.equalsIgnoreCase(a.getTitulo()) &&
compañia.equalsIgnoreCase(a.getcompañia())){
164 return true;
165 }
166 return false;
167 }
168
//Constructor
169
170
/**
171 * Constructo por defecto
172 */
173 public Videojuego(){
174 this("",HORAS_ESTIMADAS_DEF, "", "");
}
175
176 /**
177 * Constructor con 2 parametros
178 * @param titulo del videojuego
179 * @param compañia del videojuego
*/
180
public Videojuego(String titulo, String compañia){
181 this(titulo,HORAS_ESTIMADAS_DEF, "", compañia);
182 }
183
184 /**
185 * Constructor con 4 parametros
* @param titulo del videojuego
186
* @param horas estimadas del videojuego
187 * @param genero del videojuego
188 * @param compañia del videojuego
189 */
190 public Videojuego(String titulo, int horasEstimadas, String genero, String compa
this.titulo=titulo;
191
this.horasEstimadas=horasEstimadas;
192 this.genero=genero;
193 this.compañia=compañia;
194 this.entregado=false;
195 }
196
}
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
–Interfaz Entregable
1 public interface Entregable {
2
3 public void entregar();
4
5 public void devolver();
6
7 public boolean isEntregado();
8
9 public int compareTo(Object a);
}
10
–Clase ejecutable
1 public class EntregablesApp {
2
public static void main(String[] args) {
3
4 //Creamos dos arrays de cada tipo de objeto
5 Serie listaSeries[]=new Serie[5];
6 Videojuego listaVideojuegos[]=new Videojuego[5];
7
8 //Creamos un objeto en cada posicion del array
9 listaSeries[0]=new Serie();
listaSeries[1]=new Serie("Juego de tronos", "George R. R. Martin ");
10 listaSeries[2]=new Serie("Los Simpsons", 25, "Humor", "Matt Groening");
11 listaSeries[3]=new Serie("Padre de familia", 12 ,"Humor", "Seth MacFarlane");
12 listaSeries[4]=new Serie("Breaking Bad", 5, "Thriller", "Vince Gilligan");
13
14 listaVideojuegos[0]=new Videojuego();
15 listaVideojuegos[1]=new Videojuego("Assasin creed 2", 30, "Aventura", "EA");
listaVideojuegos[2]=new Videojuego("God of war 3", "Santa Monica");
16 listaVideojuegos[3]=new Videojuego("Super Mario 3DS", 30, "Plataforma", "Nin
17 listaVideojuegos[4]=new Videojuego("Final fantasy X", 200, "Rol", "Square En
18
19 //entregamos algunos videojuegos y series
20 listaSeries[1].entregar();
listaSeries[4].entregar();
21 listaVideojuegos[0].entregar();
22 listaVideojuegos[3].entregar();
23
24 //Recorremos los arrays para contar cuantos entregados hay, tambien los devo
25
26 int entregados=0;
27
for(int i=0;i<listaSeries.length;i++){
28
if(listaSeries[i].isEntregado()){
29 entregados+=1;
30 listaSeries[i].devolver();
31
32 }
33 if(listaVideojuegos[i].isEntregado()){
entregados+=1;
34
listaVideojuegos[i].devolver();
35 }
36 }
37
38 System.out.println("Hay "+entregados+" articulos entregados");
39
40 //Creamos dos objetos con la primera posicion de cada array
Serie serieMayor=listaSeries[0];
41
Videojuego videojuegoMayor=listaVideojuegos[0];
42
43 //Recorremos el array desde la posicion 1 (no 0), comparando el mayor con la
44 del array
45 for(int i=1;i<listaSeries.length;i++){
46 if(listaSeries[i].compareTo(serieMayor)==Serie.MAYOR){
serieMayor=listaSeries[i];
47 }
48 if(listaVideojuegos[i].compareTo(videojuegoMayor)==Videojuego.MAYOR){
49 videojuegoMayor=listaVideojuegos[i];
50 }
51
52 }
53
//Mostramos toda la informacion del videojuego y serie mayor
54 System.out.println(videojuegoMayor);
55 System.out.println(serieMayor);
56 }
57
58 }
59
60
61
62
63
64
65
66
Espero que os sea de ayuda. Si tenéis dudas, preguntad. Estamos para ayudarte.