Oop

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:
 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.

 Los métodos que se implementaran son:
 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.
 esMayorDeEdad(): indica si es mayor de edad, devuelve un

booleano.
 comprobarSexo(char sexo): comprueba que el sexo introducido es

correcto. Si no es correcto, sera H. No sera visible al exterior.
 toString(): devuelve toda la información del objeto.
 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.
 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.
–Clase Persona
1 /**
* Clase Persona
2
*
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 */
private final static char SEXO_DEF='H';
14
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 */
private final int SOBREPESO=1;
27
28
//Atributos
29

30 /**
31 * Nombre de la persona
32 */
33 private String nombre;
34
/**
35 * Edad de la persona
36 */
private int edad;
37
38
/**
39 * DNI de la persona, se genera al construir el objeto
40 */
41 private String DNI;
42
43 /**
* Sexo de la persona, H hombre M mujer
44
*/
45 private char sexo;
46
47 /**
48 * Peso de la persona
49 */
private double peso;
50
51
/**
52 * Altura de la persona
53 */
54 private double altura;
55
56 //Métodos privados
57
private void comprobarSexo(char sexo){
58
59
//Si el sexo no es una H o una M, por defecto es H
60 if(sexo!='H' && sexo!='M'){
61 this.sexo='H';
62 }else{
63 this.sexo=sexo;
}
64
}
65

66 private void generarDni(){
67 final int divisor=23;
68
69 //Generamos un número de 8 digitos
70 int numDNI=((int)Math.floor(Math.random()*(100000000-10000000)+10000000));
int res=numDNI-(numDNI/divisor*divisor);
71
72
//Calculamos la letra del DNI
73 char letraDNI=generaLetraDNI(res);
74
75 //Pasamos el DNI a String
76 DNI=Integer.toString(numDNI)+letraDNI;
77 }
78
private char generaLetraDNI(int res){
79 char letras[]={'T', 'R', 'W', 'A', 'G', 'M', 'Y',
80 'F', 'P', 'D', 'X', 'B', 'N', 'J', 'Z',
'S', 'Q', 'V', 'H', 'L', 'C', 'K', 'E'};
81
82
return letras[res];
83 }
84
85 //Métodos publicos
86
87 /**
88 * Modifica el nombre de la persona
* @param nombre a cambiar
89
*/
90 public void setNombre(String nombre) {
91 this.nombre = nombre;
92 }
93
94 /**
* Modifica la edad de la persona
95
* @param edad a cambiar
96 */
97 public void setEdad(int edad) {
98 this.edad = edad;
99 }
100
/**
101
* Modifica el sexo de la persona, comprueba que es correcto
102 * @param sexo a cambiar
103 */
104 public void setSexo(char sexo) {
105 this.sexo = sexo;
}
106
107
/**
108 * Modifica el peso de la persona
109 * @param peso a cambiar
110 */
111 public void setPeso(double peso) {
this.peso = peso;
112 }
113

114 /**
115 * Modifica la altura de la persona
116 * @param altura a cambiar
117 */
public void setAltura(double altura) {
118 this.altura = altura;
119 }
120
121 /**
122 * Calcula el indice de masa corporal
123 * @return codigo numerico
*<ul><li>-1: la persona esta por debajo de su peso ideal</li>
124 *<li>0: la persona esta en su peso ideal</li>
*<li>1: la persona esta por encima de su peso ideal</li></ul>
125
*/
126 public int calcularIMC(){
127 //Calculamos el peso de la persona
128 double pesoActual=peso/(Math.pow(altura, 2));
129 //Segun el peso, devuelve un codigo
if (pesoActual>=20 && pesoActual<=25){
130
return PESO_IDEAL;
131 }else if(pesoActual<20){
132 return INFRAPESO;
133 }else{
134 return SOBREPESO;
}
135
}
136 /**
137 * Indica si la persona es mayor de edad
138 * @return true si es mayor de edad y false es menor de edad
139 */
public boolean esMayorDeEdad(){
140
boolean mayor=false;
141 if (edad>=18){
142 mayor=true;
143 }
144 return mayor;
}
145
146
/**
147 * Devuelve informacion del objeto
148 * @return cadena con toda la informacion
149 */
150 public String toString(){
String sexo="";
151
if(this.sexo=='H'){
152 sexo="hombre";
153 }else{
154 sexo="mujer";
155 }
return "Informacion de la persona:n" +
156 "Nombre: "+nombre+"n" +
157 "Sexo: "+sexo+"n" +
158 "Edad: "+edad+" añosn" +
159 "DNI: "+DNI+"n" +
160 "Peso: "+peso+" kgn" +
"Altura: "+altura+" metrosn";
161 }
162

163 /**
164 * Constructor por defecto
165 */
166 public Persona(){
this("", 0, SEXO_DEF, 0, 0);
167 }
168
169 /**
* Constructor con 3 parametroe
170
* @param nombre de la persona
171 * @param edad de la persona
172 * @param sexo de la persona
173 */
174 public Persona(String nombre, int edad, char sexo){
this(nombre, edad, sexo, 0, 0);
175
}
176

177 /**
178 * Constructor con 5 parametros
179 * @param nombre de la persona
180 * @param edad de la persona
* @param sexo de la persona
181
* @param peso de la persona
182 * @param altura de la persona
183 */
184 public Persona(String nombre, int edad, char sexo, double peso, double altura){
185 this.nombre=nombre;
this.edad=edad;
186
this.peso=peso;
187 this.altura=altura;
188 generarDni();
189 comprobarSexo(sexo);
190 }
}
191
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
1 import javax.swing.JOptionPane;
public class PersonaApp {
2
3
public static void main(String[] args) {
4

5 //Introducimos los datos
6 String nombre=JOptionPane.showInputDialog("Introduce el nombre");
7
8 String texto=JOptionPane.showInputDialog("Introduce la edad");
9 int edad=Integer.parseInt(texto);
10
texto=JOptionPane.showInputDialog("Introduce el sexo");
11
char sexo=texto.charAt(0);
12

13 texto=JOptionPane.showInputDialog("Introduce el peso");
14 double peso=Double.parseDouble(texto);
15
16 texto=JOptionPane.showInputDialog("Introduce la altura");
17 double altura=Double.parseDouble(texto);
18
//Creamos objetos con cada constructor
19
Persona persona1=new Persona();
20 Persona persona2=new Persona(nombre, edad, sexo);
21 Persona persona3=new Persona(nombre, edad, sexo, peso, altura);
22
23 //Los datos que no esten completos los insertamos con los metodos set
24 persona1.setNombre("Laura");
persona1.setEdad(30);
25
persona1.setSexo('M');
26 persona1.setPeso(60);
27 persona1.setAltura(1.60);
28
29 persona2.setPeso(90.5);
30 persona2.setAltura(1.80);
31
//Usamos metodos para realizar la misma accion para cada objeto
32
System.out.println("Persona1");
33 MuestraMensajePeso(persona1);
34 MuestraMayorDeEdad(persona1);
35 MuestraInformacion(persona1);
36
37 System.out.println("Persona2");
MuestraMensajePeso(persona2);
38
MuestraMayorDeEdad(persona2);
39 MuestraInformacion(persona2);
40
41 System.out.println("Persona3");
42 MuestraMensajePeso(persona3);
43 MuestraMayorDeEdad(persona3);
MuestraInformacion(persona3);
44
}
45

46 public static void MuestraMensajePeso(Persona p){
47 int IMC=p.calcularIMC();
48 if(IMC==p.PESO_IDEAL){
49 System.out.println("La persona esta en su peso ideal");
}else if (IMC==p.INFRAPESO){
50
System.out.println("La persona esta por debajo de su peso ideal");
51 }else{
52 System.out.println("La persona esta por encima de su peso ideal");
53 }
54 }
55
public static void MuestraMayorDeEdad(Persona p){
56
boolean mayor=p.esMayorDeEdad();
57 if(mayor){
58 System.out.println("La persona es mayor de edad");
59 }else{
60 System.out.println("La persona no es mayor de edad");
}
61
}
62

63 public static void MuestraInformacion(Persona p){
64 //Invoca el metodo toString
65 System.out.println(p);
66 }
67
}
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:

 Un constructor con la longitud que nosotros le pasemos. Generara una
contraseña aleatoria con esa longitud.
 Los métodos que implementa serán:
 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.
 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:
 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
*
6 * @version 1.0
7 */
8 public class Password {
9
//Constantes
10
11
/**
12 * Longitud por defecto
13 */
14 private final static int LONG_DEF=8;
15
16 //Atributos
17
/**
18
* Longitud de la contraseña
19 */
20 private int longitud;
21 /**
22 * caracteres de la contraseña
*/
23
private String contraseña;
24

25 //Metodos publicos
26
27 /**
28 * Devuelve la longitud
29 * @return longitud de la contraseña
*/
30
public int getLongitud() {
31 return longitud;
32 }
33
34 /**
35 * Modifica la longitud de la contraseña
* @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() {
45 return contraseña;
46 }
47
48 /**
* Genera una contraseña al azar con la longitud que este definida
49
* @return contraseña
50 */
51 public String generaPassword (){
52 String password="";
53 for (int i=0;i<longitud;i++){
//Generamos un numero aleatorio, segun este elige si añadir una minusc
54
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{
if(eleccion==2){
60
char mayusculas=(char)((int)Math.floor(Math.random()*(91-65)+6
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 /**
* Comprueba la fortaleza de la contraseña
71
* @return
72 */
73 public boolean esFuerte(){
74 int cuentanumeros=0;
75 int cuentaminusculas=0;
int cuentamayusculas=0;
76
//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 d
87 if (cuentanumeros>=5 && cuentaminusculas>=1 && cuentamayusculas>=2){
88 return true;
89 }else{
90 return false;
}
91
92
93
94
95
96
97
98
99
100 }
101
102 //Constructores
103
104 /**
105 * Crea una contraseña al azar
*/
106 public Password (){
107 this(LONG_DEF);
108 }
109
110 /**
111 * La contraseña sera la pasada por parametro
* @param password
112 */
113 public Password (int longitud){
114 this.longitud=longitud;
115 contraseña=generaPassword();
116 }
}
117
118
119
120
121
122
123
124
125
126
–Clase ejecutable
1 import javax.swing.JOptionPane;
public class PasswordApp {
2
3
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
10
texto=JOptionPane.showInputDialog("Introduce la longitud del password");
11 int longitud=Integer.parseInt(texto);
12
13 //Creamos los arrays
14 Password listaPassword[]=new Password[tamanio];
15 boolean fortalezaPassword[]=new boolean[tamanio];
16
//Creamos objetos, indicamos si es fuerte y mostramos la contraseña y su fo
17 for(int i=0;i<listaPassword.length;i++){
18 listaPassword[i]=new Password(longitud);
19 fortalezaPassword[i]=listaPassword[i].esFuerte();
20 System.out.println(listaPassword[i].getContraseña()+" "+fortalezaPasswo
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

 Un constructor con el precio y peso. El resto por defecto.
 Un constructor con todos los atributos.

 Los métodos que implementara serán:
 Métodos get de todos los atributos.
 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.
 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.
 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
A 100 €
B 80 €
C 60 €
D 50 €
E 30 €
F 10 €
TAMAÑO PR
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:

 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:
 Método get de carga.
 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.

 Un constructor con la resolución, sintonizador TDT y el resto de

atributos heredados. Recuerda que debes llamar al constructor de la
clase padre.
 Método get de resolución y sintonizador TDT.
 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.
–Clase Electrodomestico
1 /**
2 * Clase Electrodomestico
*
3
* Contiene informacion de los electrodomesticos
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
private void comprobarColor(String color){
49
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)){
encontrado=true;
57
}
58

59 }
60
61 if(encontrado){
62 this.color=color;
63 }else{
this.color=COLOR_DEF;
64
}
65

66 }
67
68 /**
69 * Comprueba el consumo energetico
70 * Solo mayusculas, si es una 'a' no lo detecta como una 'A'
* @param consumoEnergetico
71
*/
72 public void comprobarConsumoEnergetico(char consumoEnergetico){
73
74 if(consumoEnergetico>=65 && consumoEnergetico<=70){
75 this.consumoEnergetico=consumoEnergetico;
76 }else{
this.consumoEnergetico=CONSUMO_ENERGETICO_DEF;
77
}
78

79 }
80
82 /**
83 * Devuelve el precio base del electrodomestico
* @return precio base del electrodomestico
84 */
85 public double getPrecioBase() {
86 return precioBase;
87 }
88 /**
* Devuelve el color del electrodomestico
89 * @return color del elesctrodomestico
90 */
public String getColor() {
91
return color;
92 }
93
94 /**
95 * Devuelve el consumo energetico del electrodomestico
96 * @return consumo energetico del electrodomestico
*/
97
public char getConsumoEnergetico() {
98 return consumoEnergetico;
99 }
100 /**
101 * Devuelve el peso del electrodomestico
* @return peso del electrodomestico
102
*/
103 public double getPeso() {
104 return peso;
105 }
106 /**
* Precio final del electrodomestico
107
* @return precio final del electrodomestico
108 */
109 public double precioFinal(){
110 double plus=0;
111 switch(consumoEnergetico){
case 'A':
112
plus+=100;
113 break;
114 case 'B':
115 plus+=80;
116 break;
case 'C':
117
plus+=60;
118 break;
119 case 'D':
120 plus+=50;
121 break;
case 'E':
122 plus+=30;
123 break;
124 case 'F':
125 plus+=10;
126 break;
}
127

128 if(peso>=0 && peso<19){
129 plus+=10;
130 }else if(peso>=20 && peso<49){
131 plus+=50;
132 }else if(peso>=50 && peso<=79){
plus+=80;
133 }else if(peso>=80){
134 plus+=100;
}
135
136
return precioBase+plus;
137 }
138
139 //Constructores
140
141 /**
142 * Contructor por defecto
*/
143
public Electrodomestico(){
144 this(PRECIO_BASE_DEF, PESO_DEF, CONSUMO_ENERGETICO_DEF, COLOR_DEF);
145 }
146
147 /**
148 * Contructor con 2 parametros
* @param precioBase del electrodomestico
149
* @param peso del electrodomestico
150 */
151 public Electrodomestico(double precioBase, double peso){
152 this(precioBase, peso, CONSUMO_ENERGETICO_DEF, COLOR_DEF);
153 }
154
/**
155
* Constructor con 4 parametros
156 * @param precioBase
157 * @param peso
158 * @param consumoEnergetico
159 * @param color
*/
160
public Electrodomestico(double precioBase, double peso, char consumoEnergetico,
161 this.precioBase=precioBase;
162 this.peso=peso;
163 comprobarConsumoEnergetico(consumoEnergetico);
164 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 /**
* Clase Lavadora
2
*
3 * Contiene informacion de lavador
4 *
6 * @version 1.0
*/
7
public class Lavadora extends Electrodomestico{
8

9 //Constantes
10
11 /**
12 * Carga por defecto
13 */
private final static int CARGA_DEF=5;
14
15
//Atributos
16

17 /**
18 * Carga de la lavadora
19 */
20 private int carga;
21
//Métodos publicos
22
23
/**
24 * Devuelve la carga de la lavadora
25 * @return
26 */
public int getCarga() {
27
return carga;
28 }
29
30 /**
31 * Precio final de la lavadora
32 * @return precio final de la lavadora
*/
33
public double precioFinal(){
34 //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){
plus+=50;
39
}
40

41 return plus;
42 }
43
44 //Constructor
45
46 /**
* Contructor por defecto
47
*/
48 public Lavadora(){
49 this(PRECIO_BASE_DEF, PESO_DEF, CONSUMO_ENERGETICO_DEF, COLOR_DEF, CARGA_DE
50 }
51
52 /**
53
* @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
/**
62 * @param peso
* @param color
64 * @param carga
65 */
66 public Lavadora(double precioBase, double peso, char consumoEnergetico, String co
67 super(precioBase,peso, consumoEnergetico,color);
68 this.carga=carga;
}
69 }
70
71
72
73
74
75
76
77
78
79
80
81
–Clase Television
1 /**
* Clase Television
2
*
3 * Contiene informacion de una television
4 *
6 * @version 1.0
*/
7
public class Television extends Electrodomestico{
8

9 //Constantes
10
11 /**
12 * Resolucion por defecto
13 */
private final static int RESOLUCION_DEF=20;
14
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
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
double plus=super.precioFinal();
33
34
//Añadimos el codigo necesario
35 if (resolucion>40){
36 plus+=precioBase*0.3;
37 }
38 if (sintonizadorTDT){
plus+=50;
39
}
40

41 return plus;
42 }
43
44 //Constructor
45
46 /**
* Constructor por defecto
47
*/
48 public Television(){
49 this(PRECIO_BASE_DEF, PESO_DEF, CONSUMO_ENERGETICO_DEF, COLOR_DEF, RESOLUCI
50 }
51
52 /**
53
* @param precioBase
54 * @param peso
55 */
56 public Television(double precioBase, double peso){
57 this(precioBase, peso, CONSUMO_ENERGETICO_DEF, COLOR_DEF, RESOLUCION_DEF, f
}
58
59
/**
62 * @param peso
* @param color
64 * @param resolucion
65 * @param sintonizadorTDT
66 */
67 public Television(double precioBase, double peso, char consumoEnergetico, String
68 super(precioBase, peso, consumoEnergetico, color);
this.resolucion=resolucion;
69 this.sintonizadorTDT=sintonizadorTDT;
70 }
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);
13 listaElectrodomesticos[8]=new Television(200, 60, 'C', "naranja", 30, true)
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
20 //Recorremos el array invocando el metodo precioFinal
for(int i=0;i<listaElectrodomesticos.length;i++){
21
/*
22 * Cunado una Television o una Lavadora este en la posicion del array a
23 * pasara por su clase y por la de electrodomestico, ya que una televis
24 * Ejecutamos en cada uno su propia version del metodo precioFinal
25 */
26
if(listaElectrodomesticos[i] instanceof Electrodomestico){
27
sumaElectrodomesticos+=listaElectrodomesticos[i].precioFinal();
28 }
29 if(listaElectrodomesticos[i] instanceof Lavadora){
30 sumaLavadoras+=listaElectrodomesticos[i].precioFinal();
31 }
if(listaElectrodomesticos[i] instanceof Television){
32
sumaTelevisiones+=listaElectrodomesticos[i].precioFinal();
33 }
34 }
35
36
37
38
39 //Mostramos los resultados
40 System.out.println("La suma del precio de los electrodomesticos es de "+sum
41 System.out.println("La suma del precio de las lavadoras es de "+sumaLavador
42 System.out.println("La suma del precio de las televisiones es de "+sumaTele
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.

 Un constructor con el titulo y creador. El resto por defecto.
 Un constructor con todos los atributos, excepto de entregado.

 Métodos get de todos los atributos, excepto de entregado.
 Métodos set de todos los atributos, excepto de entregado.
 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.

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

 Un constructor con todos los atributos, excepto de entregado.
 Métodos get de todos los atributos, excepto de entregado.
 Métodos set de todos los atributos, excepto de entregado.
 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()).
–Clase Serie
1 /**
* Clase Serie
2
*
3 * Contiene informacion sobre una serie (en general)
5 * @version 1.0
6 *
*/
7
public class Serie implements Entregable{
8
9 //Constantes
10
/**
11
* Numero de temporadas por defecto
12 */
13 private final static int NUM_TEMPORADAS_DEF=3;
14
15 /**
16 * Constante que indica que un objeto es mayor que otro
*/
17
public final static int MAYOR=1;
18

19 /**
20 * Constante que indica que un objeto es menor que otro
21 */
22 public final static int MENOR=-1;
23
/**
24
* Constante que indica que un objeto es igual que otro
25 */
26 public final static int IGUAL=0;
27
28 //Atributos
29
30 /**
* Titulo de la serie
31
*/
32 private String titulo;
33
34 /**
35 * Numero de temporadas de la serie
36 */
private int numeroTemporadas;
37
38
/**
39 * Indica si esta entregado la serie
40 */
41 private boolean entregado;
42
43 /**
* Genero de la serie
44 */
45 private String genero;
46
47 /**
48 * Creador de la serie
49 */
private String creador;
50
51
//Métodos publicos
52
53 /**
* Devuelve el titulo de la serie
54
* @return titulo de la serie
55 */
56 public String getTitulo() {
57 return titulo;
58 }
59
/**
60
* Modifica el titulo de la serie
61 * @param titulo a cambiar
62 */
63 public void setTitulo(String titulo) {
64 this.titulo = titulo;
}
65
66
/**
67 * Devuelve la numeroTemporadas de la serie
68 * @return numeroTemporadas de la serie
69 */
70 public int getnumeroTemporadas() {
return numeroTemporadas;
71
}
72

73 /**
74 * Modifica la numeroTemporadas de la serie
75 * @param numeroTemporadas a cambiar
76 */
public void setnumeroTemporadas(int numeroTemporadas) {
77
this.numeroTemporadas = numeroTemporadas;
78 }
79
80 /**
81 * Devuelve el genero de la serie
82 * @return genero de la serie
*/
83
public String getGenero() {
84 return genero;
85 }
86
87 /**
88 * Modifica el genero de la serie
* @param genero a cambiar
89 */
90 public void setGenero(String genero) {
91 this.genero = genero;
92 }
93
94 /**
* Devuelve el creador de la serie
95 * @return creador de la serie
96 */
public String getcreador() {
97
return creador;
98 }
99
100 /**
101 * Modifica el creador de la serie
102 * @param creador a cambiar
*/
103
public void setcreador(String creador) {
104 this.creador = creador;
105 }
106
107 /**
108 * Cambia el estado de entregado a true
*/
109
public void entregar() {
110 entregado=true;
111 }
112
113 /**
114 * Cambia el estado de entregado a false
*/
115
public void devolver() {
116 entregado=false;
117 }
118
119 /**
120 * Indica el estado de entregado
*/
121
public boolean isEntregado() {
122 if(entregado){
123 return true;
124 }
125 return false;
}
126
127
/**
128 * Compara dos series segun su numero de temporadas
129 * @param objeto a comparar
130 * @return codigo numerico
131 * <ul>
* <li>1: La Serie 1 es mayor que la Serie 2</li>
132 * <li>0: Las Series son iguales</li>
133 * <li>-1: La Serie 1 es menor que la Serie 2</li></ul>
134 */
135 public int compareTo(Object a) {
136 int estado=MENOR;
137
//Hacemos un casting de objetos para usar el metodo get
138 Serie ref=(Serie)a;
139 if (numeroTemporadas>ref.getnumeroTemporadas()){
140 estado=MAYOR;
}else if(numeroTemporadas==ref.getnumeroTemporadas()){
141
estado=IGUAL;
142 }
143
144 return estado;
145 }
146
147 /**
* Muestra informacion de la Serie
148
* @return cadena con toda la informacion de la Serie
149 */
151 return "Informacion de la Serie: n" +
152 "tTitulo: "+titulo+"n" +
"tNumero de temporadas: "+numeroTemporadas+"n" +
153
"tGenero: "+genero+"n" +
154 "tCreador: "+creador;
155 }
156
157 /**
158 * Indica si dos Series son iguales, siendo el titulo y creador iguales
* @param a Serie a comparar
159
* @return true si son iguales y false si son distintos
160 */
161 public boolean equals(Serie a){
162 if (titulo.equalsIgnoreCase(a.getTitulo()) && creador.equalsIgnoreCase(a.g
163 return true;
}
164
return false;
165 }
166
167 //Constructor
168
169 /**
170 * Constructor por defecto
*/
171
public Serie(){
172 this("",NUM_TEMPORADAS_DEF, "", "");
173 }
174
175 /**
* @param titulo de la Serie
177 * @param creador de la Serie
178 */
179 public Serie(String titulo, String creador){
180 this(titulo,NUM_TEMPORADAS_DEF, "", creador);
181 }
182
/**
184 * @param titulo de la Serie
* @param numeroTemporadas de la Serie
185
* @param genero de la Serie
186 * @param creador de la Serie
187 */
188 public Serie(String titulo, int numeroTemporadas, String genero, String creador
189 this.titulo=titulo;
this.numeroTemporadas=numeroTemporadas;
190
this.genero=genero;
191 this.creador=creador;
192 this.entregado=false;
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
226
227
228
229
230
–Clase Videojuego
1 /**
*
2
* Clase videojuego
3 *
4 * Contiene la informacion sobre un videojuego
5 *
* @version 1.0
7
*/
8 public class Videojuego implements Entregable{
9
10 //Constantes
11
12 /**
13 * Horas estimadas por defecto
*/
14
private final static int HORAS_ESTIMADAS_DEF=100;
15

16 /**
17 * Constante que indica que un objeto es mayor que otro
18 */
19 public final static int MAYOR=1;
20
/**
21
* Constante que indica que un objeto es menor que otro
22 */
23 public final static int MENOR=-1;
24
25 /**
26 * Constante que indica que un objeto es igual que otro
*/
27
public final static int IGUAL=0;
28

29 //Atributos
30
31 /**
32 * Titulo del videojuego
33 */
private String titulo;
34
35
/**
36 * Horas estimadas del videojuego
37 */
38 private int horasEstimadas;
39
40 /**
* Indica si esta o no entregado el videojuego
41 */
private boolean entregado;
42
43
/**
44 * Genero del videojuego
45 */
46 private String genero;
47
48 /**
* Compañia del videojuego
49
*/
50 private String compañia;
51
53
54 /**
55 * Devuelve el titulo del videojuego
* @return titulo del videojuego
56
*/
58 return titulo;
59 }
60
61 /**
* Modifica el titulo del videojuego
62
* @param titulo a cambiar
63 */
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
* @param objeto a comparar
130
* @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 */
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.
return true;
164 }
165 return false;
166 }
167
168 //Constructor
169
170 /**
* Constructo por defecto
171 */
172 public Videojuego(){
173 this("",HORAS_ESTIMADAS_DEF, "", "");
}
174
175
/**
177 * @param titulo del videojuego
178 * @param compañia del videojuego
179 */
public Videojuego(String titulo, String compañia){
180
this(titulo,HORAS_ESTIMADAS_DEF, "", compañia);
181 }
182
183 /**
185 * @param titulo del videojuego
* @param horas estimadas del videojuego
186
* @param genero del videojuego
187 * @param compañia del videojuego
188 */
189 public Videojuego(String titulo, int horasEstimadas, String genero, String comp
190 this.titulo=titulo;
this.horasEstimadas=horasEstimadas;
191
this.genero=genero;
192 this.compañia=compañia;
193 this.entregado=false;
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
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
public int compareTo(Object a);
9
}
10
–Clase ejecutable
1 public class EntregablesApp {
2
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", "Ni
17 listaVideojuegos[4]=new Videojuego("Final fantasy X", 200, "Rol", "Square E
18
19 //entregamos algunos videojuegos y series
listaSeries[1].entregar();
20
listaSeries[4].entregar();
21 listaVideojuegos[0].entregar();
22 listaVideojuegos[3].entregar();
23
24 //Recorremos los arrays para contar cuantos entregados hay, tambien los dev
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 l
44 for(int i=1;i<listaSeries.length;i++){
45 if(listaSeries[i].compareTo(serieMayor)==Serie.MAYOR){
46 serieMayor=listaSeries[i];
}
47
if(listaVideojuegos[i].compareTo(videojuegoMayor)==Videojuego.MAYOR){
48 videojuegoMayor=listaVideojuegos[i];
49 }
50
51 }
52
53 //Mostramos toda la informacion del videojuego y serie mayor
System.out.println(videojuegoMayor);
54 System.out.println(serieMayor);
55 }
56
57 }
58
59
60
61
62
63
64
65
66
5) Crear una clase Libro que contenga los siguientes atributos:

– ISBN
– Titulo
– Autor
– Número de páginas
Crear sus respectivos métodos get y set correspondientes para cada

atributo. Crear el método toString() para mostrar la información relativa al libro con
el siguiente formato:
“El libro con ISBN creado por el autor tiene páginas”
En el fichero main, crear 2 objetos Libro (los valores que se quieran) y mostrarlos
por pantalla.
Por último, indicar cuál de los 2 tiene más páginas.
–Clase Libro
1 public class Libro {
2
3 /*Atributos*/
private int ISBN;
4 private String titulo;
5 private String autor;
6 private int numPaginas;
7
8 /*Constructores*/
9
10 public Libro(int pISBN, String pTitulo, String pAutor, int pNumPaginas){
11
ISBN=pISBN;
12 titulo=pTitulo;
13 autor=pAutor;
14 numPaginas=pNumPaginas;
15
16 }
17
18 /*Metodos*/
19
20 public int getISBN() {
return ISBN;
21
}
22

23 public void setISBN(int ISBN) {
24 this.ISBN = ISBN;
25 }
26
return titulo;
28
}
29

32 }
33
34 public String getAutor() {
return autor;
35
}
36

37 public void setAutor(String autor) {
38 this.autor = autor;
39 }
40
41 public int getNumPaginas() {
return numPaginas;
42
}
43

44 public void setNumPaginas(int numPaginas) {
45 this.numPaginas = numPaginas;
46 }
47
48 @Override
public String toString(){
49
return "El libro "+titulo+" con ISBN "+ISBN+""
50 + " creado por el autor "+autor
51 + " tiene "+numPaginas+" páginas";
52 }
53
54
55
56 }
57
58
59
60
61
62
63
–Clase principal
1
2 public class Principal {
3
5
6 //Creamos lo objetos
7 Libro libro1=new Libro(1111111111, "titulo1", "autor1", 30);
Libro libro2=new Libro(1111111112, "titulo2", "autor2", 60);
8

9
//Mostramos su estado
10 System.out.println(libro1.toString());
11 System.out.println(libro2.toString());
12
13 //Modificamos el atributo numPaginas del libro1
14 libro1.setNumPaginas(70);
15
//Comparamos quien tiene mas paginas
16
if(libro1.getNumPaginas()>libro2.getNumPaginas()){
17 System.out.println(libro1.getTitulo()+" tiene más páginas");
18 }else{
19 System.out.println(libro2.getTitulo()+" tiene más páginas");
20 }
21
22
23 }
24
}
25
26
6) Vamos a realizar una clase llamada Raices, donde representaremos los valores
de una ecuación de 2º grado.
Tendremos los 3 coeficientes como atributos, llamémosles a, b y c.
Hay que insertar estos 3 valores para construir el objeto.
Las operaciones que se podrán hacer son las siguientes:
 obtenerRaices(): imprime las 2 posibles soluciones
 obtenerRaiz(): imprime única raíz, que será cuando solo tenga una solución
posible.
 getDiscriminante(): devuelve el valor del discriminante (double), el

discriminante tiene la siguiente formula, (b^2)-4*a*c
 tieneRaices(): devuelve un booleano indicando si tiene dos soluciones, para
que esto ocurra, el discriminante debe ser mayor o igual que 0.
 tieneRaiz(): devuelve un booleano indicando si tiene una única solución,

para que esto ocurra, el discriminante debe ser igual que 0.
 calcular(): mostrara por consola las posibles soluciones que tiene nuestra
ecuación, en caso de no existir solución, mostrarlo también.
Formula ecuación 2º grado: (-b±√((b^2)-(4*a*c)))/(2*a)
Solo varia el signo delante de -b
–Clase Raices
1 /**
* Clase Raices
2
* Representa una ecuacion de 2º grado
3 * @author discoduroderoer
4 */
5 public class Raices {
6
7 /*Atributos*/
private double a;
8
private double b;
9 private double c;
10
11 /**
12 * Ecuacion de 2º grado
13 * @param a
14 * @param b
* @param c
15 */
16 public Raices(double a, double b, double c){
17 this.a=a;
18 this.b=b;
19 this.c=c;
}
20

21 /**
22 * Metodos para obtener las raices cuando hay 2 soluciones posibles
23 */
24 private void obtenerRaices(){
25
26 double x1=(-b+Math.sqrt(getDiscriminante()))/(2*a);
double x2=(-b-Math.sqrt(getDiscriminante()))/(2*a);
27

28 System.out.println("Solucion X1");
29 System.out.println(x1);
30 System.out.println("Solucion X2");
31 System.out.println(x2);
32 }
33
/**
34 * Obtiene una unica raiz, cuando solo tiene la posibilidad de er una solucion
*/
35
private void obtenerRaiz(){
36

37 double x=(-b)/(2*a);
38
39 System.out.println("Unica solucion");
40 System.out.println(x);
41
42 }
43
44 /**
* Nos devuelve el valor del discriminante,
45 * @return
46 */
47 private double getDiscriminante(){
48 return Math.pow(b, 2)-(4*a*c);
49 }
50
/**
51
* Si el discriminante es mayor que 0 tiene mas de una raiz
52 * (No hemos puesto >= ya que puede confundirse con una solucion)
53 * @return
54 */
55 private boolean tieneRaices(){
return getDiscriminante()>0;
56 }
57

58 /**
59 * Si el discriminante es igual a cero tiene una sola raiz
60 * @return
61 */
private boolean tieneRaiz(){
62
return getDiscriminante()==0;
63 }
64
65 /**
66 * Nos permite calcular las raices de una ecuacion de 2º grado
67 */
public void calcular(){
68

69
if(tieneRaices()){
70 obtenerRaices();
71 }else if(tieneRaiz()){
72 obtenerRaiz();
73 }else{
System.out.println("No tiene soluciones");
74
}
75

76 }
77
78
79
80
81
82
83
84 }
85
86
87
88
89
90
91
–Clase Principal
2
4 Raices ecuacion=new Raices(1,4,4); //creamos el objeto
5 ecuacion.calcular(); //Calculamos
6
}
7
8
}
9
7) Queremos representar con programación orientada a objetos, un aula con

estudiantes y un profesor.
Tanto de los estudiantes como de los profesores necesitamos saber su nombre,
edad y sexo. De los estudiantes, queremos saber también su calificación actual
(entre 0 y 10) y del profesor que materia da.
Las materias disponibles son matemáticas, filosofía y física.
Los estudiantes tendrán un 50% de hacer novillos, por lo que si hacen novillos no
van a clase pero aunque no vayan quedara registrado en el aula (como que cada
uno tiene su sitio).
El profesor tiene un 20% de no encontrarse disponible (reuniones, baja, etc.)
Las dos operaciones anteriores deben llamarse igual en Estudiante y Profesor
(polimorfismo).
El aula debe tener un identificador numérico, el número máximo de estudiantes y
para que esta destinada (matemáticas, filosofía o física). Piensa que más atributos
necesita.
Un aula para que se pueda dar clase necesita que el profesor esté disponible, que
el profesor de la materia correspondiente en el aula correspondiente (un profesor
de filosofía no puede dar en un aula de matemáticas) y que haya más del 50% de
alumnos.
El objetivo es crear un aula de alumnos y un profesor y determinar si puede darse
clase, teniendo en cuenta las condiciones antes dichas.
Si se puede dar clase mostrar cuantos alumnos y alumnas (por separado) están
aprobados de momento (imaginad que les están entregando las notas).
NOTA: Los datos pueden ser aleatorios (nombres, edad, calificaciones, etc.)
siempre y cuando tengan sentido (edad no puede ser 80 en un estudiante o
calificación ser 12).
— Clase Persona
1 //Clase Persona
public abstract class Persona {
2
3
/*Atributos*/
4 private String nombre;
5 private char sexo;
6 private int edad;
7 private boolean asistencia;
8
9 /*Contantes*/
private final String[] NOMBRES_CHICOS={"Pepe", "Fernando", "Alberto", "Nacho",
10 private final String[] NOMBRES_CHICAS={"Alicia", "Laura", "Clotilde", "Pepa", "
11 private final int CHICO=0;
12 private final int CHICA=1;
13
14 /*Constructores*/
15 public Persona(){
16
//entre 0 y 1
17 int determinar_sexo=MetodosSueltos.generaNumeroAleatorio(0,1);
18

19 //Si es 0 es un chico
20 if(determinar_sexo==CHICO){
21 nombre=NOMBRES_CHICOS[MetodosSueltos.generaNumeroAleatorio(0,4)];
22 sexo='H';
}else{
23 nombre=NOMBRES_CHICAS[MetodosSueltos.generaNumeroAleatorio(0,4)];
24 sexo='M';
25 }
26
27 //Indicamos la disponibilidad
28 disponibilidad();
29
}
30
31
/*Metodos*/
32

33 /**
34 * Devuelve el nombre
35 * @return
36 */
public String getNombre() {
37
return nombre;
38 }
39
40 /**
41 * Modifica el nombre
42 * @param nombre
*/
43
public void setNombre(String nombre) {
45 }
46
47 /**
48 * Devuelve el sexo de la persona
* @return
49
*/
50 public char getSexo() {
51 return sexo;
52 }
53
54 /**
* Modifica el sexo de la persona
55
* @param sexo
56 */
57 public void setSexo(char sexo) {
58 this.sexo = sexo;
59 }
60
/**
61
* Devuelve la edad de la persona
62 * @return
63 */
64 public int getEdad() {
65 return edad;
}
66
67
/**
68 * Modifica la edad de la edad
69 * @param edad
70 */
this.edad = edad;
72 }
73

74 /**
75 * Indica la asistencia de la persona
76 * @return
77 */
public boolean isAsistencia() {
78 return asistencia;
79 }
80
81
82
83
84
85
86
87
88 /**
89 * Modifica la asistencia de la persona
90 * @param asistencia
*/
91
public void setAsistencia(boolean asistencia) {
92 this.asistencia = asistencia;
93 }
94
95 //abtracto, las clases hijas deben implementarlo
96 public abstract void disponibilidad();
97
}
98
99
100
101
102
103
104
105
— Clase Alumno
1 //Clase Alumno, hereda de la clase Persona
public class Alumno extends Persona{
2
3
/*Atributos*/
4 private int nota;
5
6 /*Constructor*/
7 public Alumno(){
8 super();
9
10 nota=MetodosSueltos.generaNumeroAleatorio(0,10);
11
super.setEdad(MetodosSueltos.generaNumeroAleatorio(12,15));
12

13
}
14

15 /*Metodos*/
16
17 /**
18 * Devuelve la nota
* @return nota del alumno
19
*/
20

21 public int getNota() {
22 return nota;
23 }
24
25 /**
* Modifica la nota del alumno
26
* @param nota
27 */
28 public void setNota(int nota) {
29 this.nota = nota;
30 }
31
/**
32
* Indica si el alumno esta disponible (50%)
33 */
34 @Override
35 public void disponibilidad() {
36
37 int prob=MetodosSueltos.generaNumeroAleatorio(0, 100);
38
39 if(prob<50){
super.setAsistencia(false);
40 }else{
41 super.setAsistencia(true);
42 }
43
44 }
45
46 /**
* Muestra la informacion del alumno
47 * @return informacion
48 */
50
51 return "Nombre: "+super.getNombre()+" ,sexo: "+super.getSexo()+" , nota: "+
52
53 }
54
55
56
57
58 }
59
60
61
62
63
64
65
— Clase Profesor
1 //Clase profesor que hereda de la clase Persona
public class Profesor extends Persona{
2
3
/*Atributos*/
4 private String materia;
5
6 /*Constructores*/
7 public Profesor(){
8 super(); //Llama al constructor padre
9
10 super.setEdad(MetodosSueltos.generaNumeroAleatorio(25,50)); //llama al metod
11
materia=Constantes.MATERIAS[MetodosSueltos.generaNumeroAleatorio(0,2)];
12 }
13

14 /*Metodos*/
15
16 /**
17 * Devuelve la materia del profesor
18 * @return
*/
19 public String getMateria() {
20 return materia;
21 }
22
23 /**
24 * Modifica la materia del profesor
* @param materia
25 */
26 public void setMateria(String materia) {
27 this.materia = materia;
28 }
29
30 /**
* Calcula la disponibilidad del profesor(20%)
31 */
32 @Override
33 public void disponibilidad() {
34
35 int prob=MetodosSueltos.generaNumeroAleatorio(0, 100);
36
37 if(prob<20){
super.setAsistencia(false);
38
}else{
39 super.setAsistencia(true);
40
41
42
43 }
44
45 }
46
47 }
48
49
50
— Clase Aula
1 public class Aula {
2
3 /*Atributos*/
private int id;
4 private Profesor profesor;
5 private Alumno[] alumnos;
6 private String materia;
7
8 /*Constantes*/
9 private final int MAX_ALUMNOS=20;
10
/*Constructores*/
11 public Aula(){
12
13 id=1;
14
15 profesor=new Profesor();
16 alumnos= new Alumno[MAX_ALUMNOS];
17 creaAlumnos();
materia=Constantes.MATERIAS[MetodosSueltos.generaNumeroAleatorio(0,2)];
18

19
}
20

21 /*Metodos*/
22
23 /**
24 * Crea los alumnos para el aula
25 */
private void creaAlumnos(){
26
27
for(int i=0;i<alumnos.length;i++){
28 alumnos[i]=new Alumno();
29 }
30
31 }
32
33
34 /**
35 * Indica si la asistencia de los alumnos es mayor del 50%
* @return
36 */
37 private boolean asistenciaAlumnos(){
38
39 int cuentaAsistencias=0;
40
41 //contamos las asistencias
42 for(int i=0;i<alumnos.length;i++){
43
if(alumnos[i].isAsistencia()){
44 cuentaAsistencias++;
45 }
46
47 }
48
49 //Muestro la asistencia total
50 System.out.println("Hay "+cuentaAsistencias+" alumnos");
51
return cuentaAsistencias>=((int)(alumnos.length/2));
52
53
}
54

55 /**
56 * Indicamos si se puede dar clase
57 * @return
58 */
59 public boolean darClase(){
60
//Indicamos las condiciones para que se pueda dar la clase
61

62 if(!profesor.isAsistencia()){
63 System.out.println("El profesor no esta, no se puede dar clase");
64 return false;
65 }else if(!profesor.getMateria().equals(materia)){
66 System.out.println("La materia del profesor y del aula no es la misma,
return false;
67 }else if (!asistenciaAlumnos()){
68 System.out.println("La asistencia no es suficiente, no se puede dar cl
69 return false;
70 }
71
72 System.out.println("Se puede dar clase");
return true;
73

74
}
75

76 /**
77
78
79
80
81
82
83 * Indicamos las notas de los alumnos aprobados, chicos y chicas
84 */
85 public void notas(){
86
87 int chicosApro=0;
88 int chicasApro=0;
89
for(int i=0;i<alumnos.length;i++){
90

91
//Comprobamos si el alumno esta aprobado
92 if(alumnos[i].getNota()>=5){
93 //Segun el sexo, aumentara uno o otro
94 if(alumnos[i].getSexo()=='H'){
95 chicosApro++;
}else{
96
chicasApro++;
97 }
98
99 System.out.println(alumnos[i].toString());
100
101 }
102
103 }
104
105 System.out.println("Hay "+chicosApro+" chicos y "+chicasApro+" chicas apro
106
}
107

108 }
109
110
111
112
113
114
115
— Clase Constantes
1 //Clase constantes
public class Constantes {
2
3
public static final String[] MATERIAS={"Matematicas", "Filosofia", "Fisica"};
4

5 }
6
— Clase MetodosSueltos
1
2 public class MetodosSueltos {
3
4 /**
* Genera un numero aleatorio entre dos numeros.
5 * Entre el minimo y el maximo
6 * @param minimo
7 * @param maximo
8 * @return numero entre minimo y maximo
9 */
public static int generaNumeroAleatorio(int minimo, int maximo){
10

11 int num=(int)Math.floor(Math.random()*(minimo-(maximo+1))+(maximo+1));
12 return num;
13 }
14
15 }
16
— Clase Principal
1
public class Principal {
2
3
4

5 //Creamos el objeto
6 Aula aula=new Aula();
7
8 //Indicamos si se puede dar la clase
9 if(aula.darClase()){
aula.notas();
10
}
11

12 }
13
14 }
15
8) Nos piden hacer un programa orientado a objetos sobre un cine (solo de una
sala) tiene un conjunto de asientos (8 filas por 9 columnas, por ejemplo).
Del cine nos interesa conocer la película que se está reproduciendo y el precio de
la entrada en el cine.
De las películas nos interesa saber el título, duración, edad mínima y director.
Del espectador, nos interesa saber su nombre, edad y el dinero que tiene.
Los asientos son etiquetados por una letra (columna) y un número (fila), la fila 1
empieza al final de la matriz como se muestra en la tabla. También deberemos
saber si está ocupado o no el asiento.
8A8B8C8D8E8F8G8H8I
7A7B7C7D7E7F7G7H7I
6A6B6C6D6E6F6G6H6I
5A5B5C5D5E5F5G5H5I
4A4B4C4D4E4F4G4H4I
3A3B3C3D3E3F3G3H3I
2A2B2C2D2E2F2G2H2I
1A1B1C1D1E1F1G1H1I
Realizaremos una pequeña simulación, en el que generaremos muchos

espectadores y los sentaremos aleatoriamente (no podemos donde ya este
ocupado).
En esta versión sentaremos a los espectadores de uno en uno.
Solo se podrá sentar si tienen el suficiente dinero, hay espacio libre y tiene edad
para ver la película, en caso de que el asiento este ocupado le buscamos uno
libre.
Los datos del espectador y la película pueden ser totalmente aleatorios.
— Clase Espectador
1 /**
* Clase Espectador, lleva todo lo relativo a la información del espectador
2
*
3 * @author DiscoDurodeRoer
4 */
5 public class Espectador {
6
7 /*Atributos*/
private String nombre;
8
private int edad;
9 private double dinero;
10
12 public Espectador(String nombre, int edad, double dinero) {
this.edad = edad;
14
this.dinero = dinero;
15 }
16
17 /*Metodos*/
18 public String getNombre() {
19 return nombre;
}
20
21
22 public void setNombre(String nombre) {
this.nombre = nombre;
23
}
24

25 public int getEdad() {
26 return edad;
27 }
28
this.edad = edad;
30
}
31

32 public double getDinero() {
33 return dinero;
34 }
35
36 public void setDinero(double dinero) {
this.dinero = dinero;
37
}
38

39 /**
40 * Pagamos la entrada del cine
41 *
42 * @param precio
*/
43
public void pagar(double precio) {
44 dinero -= precio;
45 }
46
47 /**
48 * Indicamos si el espectador tiene edad para ver la pelicula (en el video
* estaba en la clase pelicula tiene mas sentido que sea un metodo del
49
* espectador)
50 *
51 * @param edadMinima
52 * @return
53 */
public boolean tieneEdad(int edadMinima) {
54
return edad >= edadMinima;
55 }
56
57 /**
58 * Indicamos si el espectador tiene dinero (en el video estaba en la clase
59 * cine tiene mas sentido que sea un metodo del espectador)
*
60 * @param precioEntrada
61 * @return
62 */
63 public boolean tieneDinero(double precioEntrada) {
64 return dinero >= precioEntrada;
}
65
66
67
68
69
70
71
72 @Override
public String toString() {
73 return "el nombre del espectador es " + nombre + " de " + edad + " años y co
74 }
75
76 }
77
78
79
80
81
82
— Clase Asiento
1 /**
* Clase asiento, se usa para manejar toda la informacion relativa al asiento
2
*
4 */
5 public class Asiento {
6
7 /*Atributos*/
private char letra;
8
private int fila;
9 private Espectador espectador; // informacion del espectador que esta sentado,
10
12 public Asiento(char letra, int fila) {
13 this.letra = letra;
this.fila = fila;
14
this.espectador = null; //al iniciar el asiento, no habrá nadie sentado
15 }
16
17 /*Metodos*/
18 public char getLetra() {
19 return letra;
}
20
21
public void setLetra(char letra) {
22 this.letra = letra;
23 }
24
25 public int getFila() {
26
27
28
29
30 return fila;
31 }
32
33 public void setFila(int fila) {
this.fila = fila;
34 }
35

36 public Espectador getEspectador() {
37 return espectador;
38 }
39
40 public void setEspectador(Espectador espectador) {
this.espectador = espectador;
41 }
42

43 /**
44 * Indica si el asiento esta ocupado
45 *
46 * @return
*/
47 public boolean ocupado() {
48 return espectador != null;
49 }
50
51 @Override
52 public String toString() {
if (ocupado()) {
53 return "Asiento: " + fila + letra + " y " + espectador;
54 }
55
56 return "Asiento: " + fila + letra + " y este asiento está vacio ";
57
58 }
59
60 }
61
62
63
64
— Clase Pelicula
1 /**
2 * Clase Pelicula, lleva todo lo relacionado con la pelicula
*
4 */
5 public class Pelicula {
6
/*Atributos*/
7
private String titulo;
8 private int duracion;
9 private int edadMinima;
10 private String director;
11
12 /*Constructor*/
public Pelicula(String titulo, int duracion, int edadMinima, String director) {
13
this.titulo = titulo;
14 this.duracion = duracion;
15 this.edadMinima = edadMinima;
16 this.director = director;
17 }
18
/*Metodos*/
19
public String getTitulo() {
20 return titulo;
21 }
22
}
25
26
public int getDuracion() {
27 return duracion;
28 }
29
30 public void setDuracion(int duracion) {
31 this.duracion = duracion;
}
32
33
public int getEdadMinima() {
34 return edadMinima;
35 }
36
37 public void setEdadMinima(int edadMinima) {
38 this.edadMinima = edadMinima;
}
39
40
public String getDirector() {
41 return director;
42 }
43
44 public void setDirector(String director) {
45 this.director = director;
}
46
47
@Override
48 public String toString() {
49
50
51
52
53 return "'" + titulo + "' del director " + director + ", con una duracion de " +
54 }
55
56 }
57
58
59
60
— Clase Cine
1 /**
* Clase Cine, lleva todo lo relativo al cine
2
*
4 */
5 public class Cine {
6
7 /*Atributos*/
private Asiento asientos[][];
8
private double precio;
9 private Pelicula pelicula;
10
11 /*Constructor*/
12 public Cine(int filas, int columnas, double precio, Pelicula pelicula) {
13
14 asientos = new Asiento[filas][columnas];
this.precio = precio;
15
this.pelicula = pelicula;
16 rellenaButacas();
17 }
18
19 /*Metodos*/
20 public Asiento[][] getAsientos() {
return asientos;
21
}
22

23 public void setAsientos(Asiento[][] asientos) {
24 this.asientos = asientos;
25 }
26
27 public double getPrecio() {
return precio;
28
}
29

30 public void setPrecio(double precio) {
31 this.precio = precio;
32 }
33
public Pelicula getPelicula() {
34
return pelicula;
35 }
36
37 public void setPelicula(Pelicula pelicula) {
38 this.pelicula = pelicula;
39 }
40
/**
41
* Rellena nuestros asientos, dandoles una fila y una letra
42 */
43 private void rellenaButacas() {
44
45 int fila = asientos.length;
46 for (int i = 0; i < asientos.length; i++) {
for (int j = 0; j < asientos[0].length; j++) {
47
//Recuerda que los char se pueden sumar
48 asientos[i][j] = new Asiento((char) ('A' + j), fila);
49 }
50 fila--; //Decremento la fila para actualizar la fila
51 }
52
}
53
54
/**
55 * Indicamos si hay sitio en el cine, cuando vemos una vacia salimos de la
56 * función
57 *
58 * @return
*/
59
public boolean haySitio() {
60

61 for (int i = 0; i < asientos.length; i++) {
62 for (int j = 0; j < asientos[0].length; j++) {
63
64 if (!asientos[i][j].ocupado()) {
65 return true;
}
66
67
}
68 }
69
70 return false;
71 }
72
73 /**
* Indico si en una posicion concreta esta ocupada
74 *
75 * @param fila
76 * @param letra
* @return
77
*/
78 public boolean haySitioButaca(int fila, char letra) {
79 return getAsiento(fila, letra).ocupado();
80 }
81
82 /**
* Indicamos si el espectador cumple lo necesario para entrar: - Tiene
83
* dinero - Tiene edad El tema de si hay sitio, se controla en el main
84 *
85 * @param e
86 * @return
87 */
public boolean sePuedeSentar(Espectador e) {
88
return e.tieneDinero(precio) && e.tieneEdad(pelicula.getEdadMinima());
89 }
90
91 /**
92 * Siento al espectador en un asiento
93 *
* @param fila
94
* @param letra
95 * @param e
96 */
97 public void sentar(int fila, char letra, Espectador e) {
98 getAsiento(fila, letra).setEspectador(e);
}
99
100
/**
101 * Devuelvo un asiento concreto por su fila y letra
102 *
103 * @param fila
104 * @param letra
* @return
105
*/
106 public Asiento getAsiento(int fila, char letra) {
107 return asientos[asientos.length - fila - 1][letra - 'A'];
108 }
109
110 /**
* Numero de filas de nuestro cine
111 *
112 * @return
113 */
114 public int getFilas() {
115 return asientos.length;
}
116
117
/**
118 * Numero de columas de nuestro cine
119 *
120 * @return
*/
121
public int getColumnas() {
122 return asientos[0].length;
123 }
124
125 /**
126 * Mostramos la información de nuestro cine (Tambien se puede hacer en un
* toString pero hay que devolver un String)
127
*/
128 public void mostrar() {
129
130 System.out.println("Información cine");
131 System.out.println("Pelicula reproducida: " + pelicula);
132 System.out.println("Precio entrada: " + precio);
System.out.println("");
133
for (int i = 0; i < asientos.length; i++) {
134 for (int j = 0; j < asientos[0].length; j++) {
135 System.out.println(asientos[i][j]);
136 }
137 System.out.println("");
}
138
}
139

140 }
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
— Clase Metodos
1
2 /**
* Clase Metodos, contiene funciones útiles para nuestro programa
3
*
4 * @author DiscoDuroDeroer
5 */
6 public class Metodos {
7
8 public static final String nombres[] = {"Fernando", "Laura", "Pepe", "Eufrasio"}
9
public static int generaNumeroEnteroAleatorio(int minimo, int maximo) {
10
int num = (int) (Math.random() * (minimo - (maximo + 1)) + (maximo + 1));
11 return num;
12 }
13
14 }
15
— Clase Principal
1 import java.util.Scanner;
2
/**
3
* Clase ejecutable
5 */
7
9
//Creo la pelicula
10
Pelicula pelicula = new Pelicula("Mi vida", 90, 16, "DDR");
11

12 // Pido datos (esto no se mostro en el video por falta de tiempo)
13 // No valida nada al respecto de tamaños (siguiente version)
14 Scanner sn = new Scanner(System.in);
15
16 System.out.println("Introduce el numero de filas");
17 int filas=sn.nextInt();
18
System.out.println("Intrdouce el numero de columnas");
19 int columnas=sn.nextInt();
20
21 System.out.println("Introduce el precio de la entrada de cine");
22 double precio=sn.nextDouble();
23
24 //Creo el cine, necesito la pelicula para ello
25 Cine cine = new Cine(filas, columnas, precio, pelicula);
26
27 //Numero de espectadores que seran creados
System.out.println("Introduce el numero de espectadores a crear");
28
int numEspectadores = sn.nextInt();
29

30 //Variables y objetos usados
31 Espectador e;
32 int fila;
33 char letra;
34
System.out.println("Espectadores generados: ");
35
//Termino cuando no queden espectadores o no haya mas sitio en el cine
36 for (int i = 0; i < numEspectadores && cine.haySitio(); i++) {
37
38 //Generamos un espectador
39 e = new Espectador(
40 Metodos.nombres[Metodos.generaNumeroEnteroAleatorio(0, Metodos.
Metodos.generaNumeroEnteroAleatorio(10, 30), //Generamos una ed
41
Metodos.generaNumeroEnteroAleatorio(1, 10)); //Generamos el din
42

43 //Mostramos la informacion del espectador
44 System.out.println(e);
45
46 //Generamos una fila y letra
47 //Si esta libre continua sino busca de nuevo
do {
48
49
fila = Metodos.generaNumeroEnteroAleatorio(0, cine.getFilas() - 1);
50 letra = (char) Metodos.generaNumeroEnteroAleatorio('A', 'A' + (cine
51
52 } while (cine.haySitioButaca(fila, letra));
53
54 //Si el espectador cumple con las condiciones
55 if (cine.sePuedeSentar(e)) {
e.pagar(cine.getPrecio()); //El espectador paga el precio de la ent
56
cine.sentar(fila, letra, e); //El espectador se sienta
57 }
58
59 }
60
61 System.out.println("");
62 cine.mostrar(); //Mostramos la información del cine, tambien se puede usar
63
System.out.println("Fin");
64
65
}
66

67 }
68
69
70
71
72
73
74
75
76

Oop

Cargado por

Copyright:

Formatos disponibles

Oop

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Oop

Cargado por

Copyright:

Formatos disponibles

1)

Haz una clase llamada Persona que siga las siguientes condiciones:

 Sus atributos son: nombre, edad, DNI, sexo (H hombre, M mujer), peso y

 Se implantaran varios 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.

 esMayorDeEdad(): indica si es mayor de edad, devuelve un

 comprobarSexo(char sexo): comprueba que el sexo introducido es

 toString(): devuelve toda la información del objeto.

 generaDNI(): genera un numero aleatorio de 8 cifras, genera a partir

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

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

 Crea 3 objetos de la clase anterior, el primer objeto obtendrá las anteriores

 Indicar para cada objeto si es mayor de edad.

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

 Que tenga los atributos longitud y contraseña . Por defecto, la longitud

 Los constructores serán los siguiente:

 Un constructor por defecto.

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

 Método set para longitud.

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

 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

 Al final, muestra la contraseña y si es o no fuerte (usa el bucle anterior).

3) Crearemos una supeclase llamada Electrodomestico con las siguientes

 Sus atributos son precio base, color, consumo energético (letras entre A

 Por defecto, el color sera blanco, el consumo energético sera F, el

 Los constructores que se implementaran serán

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

 Un constructor con todos los atributos.

 comprobarConsumoEnergetico(char letra): comprueba que la

 comprobarColor(String color): comprueba que el color es correcto,

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:

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

 Un constructor con la carga y el resto de atributos heredados.

 Sus atributos son resolución (en pulgadas) y sintonizador

 Por defecto, la resolución sera de 20 pulgadas y el sintonizador sera false.

 Los constructores que se implementaran serán:

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

 Un constructor con la resolución, sintonizador TDT y el resto de

 precioFinal(): si tiene una resolución mayor de 40 pulgadas, se

 Crea un array de Electrodomesticos de 10 posiciones.

 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

 Sus atributos son titulo, numero de temporadas, entregado, genero y

 Por defecto, el numero de temporadas es de 3 temporadas y

 Los constructores que se implementaran serán:

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

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

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

 Sobrescribe los métodos toString.

 Sus atributos son titulo, horas estimadas, entregado, genero y

 Por defecto, las horas estimadas serán de 10 horas y entregado false. El

 Los constructores que se implementaran serán: