–Clase Cuenta

1 /**
 * Clase Cuenta
2
 * @author DiscoDurodeRoer
3  */
4 public class Cuenta {
5  
6     //Atributos
7     private String titular;
    private double cantidad;
8
9  
    //Constructores
10     public Cuenta(String titular) {
11         this(titular, 0); //Sobrecarga
12     }
13  
14     public Cuenta(String titular, double cantidad) {
        this.titular = titular;
15
        //Si la cantidad es menor que cero, lo ponemos a cero
16         if (cantidad < 0) {
17             this.cantidad = 0;
18         } else {
19             this.cantidad = cantidad;
        }
20
    }
21
 
22     //Metodos
23     public String getTitular() {
24         return titular;
25     }
26  
    public void setTitular(String titular) {
27
        this.titular = titular;
28     }
29  
30     public double getCantidad() {
        return cantidad;
31
    }
32
 
33     public void setCantidad(double cantidad) {
34         this.cantidad = cantidad;
35     }
36  
37     /**
     * Ingresa dinero en la cuenta,
38
     * solo si es positivo la cantidad
39      *
40      * @param cantidad
41      */
42     public void ingresar(double cantidad) {
        if(cantidad > 0){
43
            this.cantidad += cantidad;  
44         }
45     }
46  
47     /**
48      * Retira una cantidad en la cuenta, si se quedara en negativo se quedaria
     * en cero
49
     *
50      * @param cantidad
51      */
52     public void retirar(double cantidad) {
53         if (this.cantidad - Math.abs(cantidad) < 0) {
            this.cantidad = 0;
54
        } else {
55             this.cantidad -= cantidad;
56         }
57     }
58
59
60
61
62
63
64  
    /**
65
     * Devuelve el estado del objeto
66      *
67      * @return
68      */
69     @Override
    public String toString() {
70
        return "El titular " + titular + " tiene " + cantidad + " euros en la cuenta";
71     }
72  
73 }
74
75
76
77
78
79
–Clase ejecutable
1 public class CuentaApp {
2  
    public static void main(String[] args) {
3
4          
        Cuenta cuenta_1 = new Cuenta("DiscoDurodeRoer");
5         Cuenta cuenta_2 = new Cuenta("Fernando", 300);
6          
7
8         //Ingresa dinero en las cuentas
9         cuenta_1.ingresar(300);
10         cuenta_2.ingresar(400);
11          
12         //Retiramos dinero en las cuentas
        cuenta_1.retirar(500);
13         cuenta_2.retirar(100);
14          
15         //Muestro la informacion de las cuentas
16         System.out.println(cuenta_1); // 0 euros
17         System.out.println(cuenta_2); // 600 euros
18          
19     }
20      
}
21
22

2
/**
 * Clase Persona
 * Contiene información de una persona
 * @author DiscoDurodeRoer
 */
public class Persona {
 
    //Constantes
    /**
     * Sexo por defecto
     */
    private final static char SEXO_DEF = 'H';
 
    /**
     * El peso de la persona esta por debajo del peso ideal
     */
    public static final int INFRAPESO = -1;
 
    /**
     * El peso de la persona esta en su peso ideal
     */
    public static final int PESO_IDEAL = 0;
 
    /**
     * El peso de la persona esta por encima del peso ideal
     */
    public static final int SOBREPESO = 1;
 
    //Atributos
    /**
     * Nombre de la persona
     */
    private String nombre;
 
    /**
     * Edad de la persona
     */
    private int edad;
 
    /**
     * DNI de la persona, se genera al construir el objeto
     */
    private String DNI;
 
    /**
     * Sexo de la persona, H hombre M mujer
     */
    private char sexo;
 
    /**
     * Peso de la persona
     */
    private double peso;
 
    /**
     * Altura de la persona
     */
    private double altura;
 
    //Contructores
    /**
     * Constructor por defecto
     */
    public Persona() {
        this("", 0, SEXO_DEF, 0, 0);
    }
 
    /**
     * Constructor con 3 parametroe
     *
     * @param nombre de la persona
     * @param edad de la persona
     * @param sexo de la persona
     */
    public Persona(String nombre, int edad, char sexo) {
        this(nombre, edad, sexo, 0, 0);
    }
 
    /**
     * Constructor con 5 parametros
     *
     * @param nombre de la persona
     * @param edad de la persona
     * @param sexo de la persona
     * @param peso de la persona
     * @param altura de la persona
     */
    public Persona(String nombre, int edad, char sexo, double peso, double altura) {
        this.nombre = nombre;
        this.edad = edad;
        this.peso = peso;
        this.altura = altura;
        generarDni();
        this.sexo = sexo;
        comprobarSexo();
    }
 
    //Métodos privados
    private void comprobarSexo() {
 
        //Si el sexo no es una H o una M, por defecto es H
        if (sexo != 'H' && sexo != 'M') {
            this.sexo = SEXO_DEF;
        }
    }
 
    private void generarDni() {
        final int divisor = 23;
 
        //Generamos un número de 8 digitos
        int numDNI = ((int) Math.floor(Math.random() * (100000000 - 10000000) + 10000000));
        int res = numDNI - (numDNI / divisor * divisor);
 
        //Calculamos la letra del DNI
        char letraDNI = generaLetraDNI(res);
 
        //Pasamos el DNI a String
        DNI = Integer.toString(numDNI) + letraDNI;
    }
 
    private char generaLetraDNI(int res) {
        char letras[] = {'T', 'R', 'W', 'A', 'G', 'M', 'Y',
            'F', 'P', 'D', 'X', 'B', 'N', 'J', 'Z',
            'S', 'Q', 'V', 'H', 'L', 'C', 'K', 'E'};
 
        return letras[res];
    }
 
    //Métodos publicos
    /**
     * Modifica el nombre de la persona
     *
     * @param nombre a cambiar
     */
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
 
    /**
     * Modifica la edad de la persona
     *
     * @param edad a cambiar
     */
    public void setEdad(int edad) {
        this.edad = edad;
    }
 
    /**
     * Modifica el sexo de la persona, comprueba que es correcto
     *
     * @param sexo a cambiar
     */
    public void setSexo(char sexo) {
        this.sexo = sexo;
    }
 
    /**
     * Modifica el peso de la persona
     *
     * @param peso a cambiar
     */
    public void setPeso(double peso) {
        this.peso = peso;
    }
 
    /**
     * Modifica la altura de la persona
     *
     * @param altura a cambiar
     */
    public void setAltura(double altura) {
        this.altura = altura;
    }
 
    /**
     * Calcula el indice de masa corporal
     *
     * @return codigo numerico
     * <ul><li>-1: la persona esta por debajo de su peso ideal</li>
     * <li>0: la persona esta en su peso ideal</li>
     * <li>1: la persona esta por encima de su peso ideal</li></ul>
     */
    public int calcularIMC() {
        //Calculamos el peso de la persona
        double pesoActual = peso / (Math.pow(altura, 2));
        //Segun el peso, devuelve un codigo
        if (pesoActual >= 20 && pesoActual <= 25) {
            return PESO_IDEAL;
        } else if (pesoActual < 20) {
            return INFRAPESO;
        } else {
            return SOBREPESO;
        }
    }
 
    /**
     * Indica si la persona es mayor de edad
     *
     * @return true si es mayor de edad y false es menor de edad
     */
    public boolean esMayorDeEdad() {
        boolean mayor = false;
        if (edad >= 18) {
            mayor = true;
        }
        return mayor;
    }
 
    /**
     * Devuelve informacion del objeto
     *
     * @return cadena con toda la informacion
     */
    @Override
    public String toString() {
        String sexo;
        if (this.sexo == 'H') {
            sexo = "hombre";
        } else {
            sexo = "mujer";
        }
        return "Informacion de la persona:n"
                + "Nombre: " + nombre + "n"
                + "Sexo: " + sexo + "n"
                + "Edad: " + edad + " añosn"
                + "DNI: " + DNI + "n"
                + "Peso: " + peso + " kgn"
                + "Altura: " + altura + " metrosn";
    }
 
}

–Clase ejecutable con JOptionPane

1 import javax.swing.JOptionPane;
2  
public class PersonaApp {
3
4  
    public static void main(String[] args) {
5
 
6         //Introducimos los datos
7         String nombre = JOptionPane.showInputDialog("Introduce el nombre");
8  
9         String texto = JOptionPane.showInputDialog("Introduce la edad");
1         int edad = Integer.parseInt(texto);
0  
1         texto = JOptionPane.showInputDialog("Introduce el sexo");
        char sexo = texto.charAt(0);
1
1  
2         texto = JOptionPane.showInputDialog("Introduce el peso");
1         double peso = Double.parseDouble(texto);
3  
        texto = JOptionPane.showInputDialog("Introduce la altura");
1
        double altura = Double.parseDouble(texto);
4
 
1         //Creamos objetos con cada constructor
5         Persona persona1 = new Persona();
1         Persona persona2 = new Persona(nombre, edad, sexo);
6         Persona persona3 = new Persona(nombre, edad, sexo, peso, altura);
1  
7         //Los datos que no esten completos los insertamos con los metodos set
1         persona1.setNombre("Laura");
8         persona1.setEdad(30);
        persona1.setSexo('M');
1         persona1.setPeso(60);
9         persona1.setAltura(1.60);
2  
0         persona2.setPeso(90.5);
2         persona2.setAltura(1.80);
1  
2         //Usamos metodos para realizar la misma accion para cada objeto
2         System.out.println("Persona1");
        MuestraMensajePeso(persona1);
2
        MuestraMayorDeEdad(persona1);
3         System.out.println(persona1.toString());
2
 
4         System.out.println("Persona2");
2         MuestraMensajePeso(persona2);
5         MuestraMayorDeEdad(persona2);
2         System.out.println(persona2.toString());
6  
2         System.out.println("Persona3");
7         MuestraMensajePeso(persona3);
        MuestraMayorDeEdad(persona3);
2         System.out.println(persona3.toString());
8     }
2  
9     public static void MuestraMensajePeso(Persona p) {
3         int IMC = p.calcularIMC();
0         switch (IMC) {
3             case Persona.PESO_IDEAL:
1                 System.out.println("La persona esta en su peso ideal");
                break;
3             case Persona.INFRAPESO:
2                 System.out.println("La persona esta por debajo de su peso ideal");
3                 break;
3             case Persona.SOBREPESO:
3                 System.out.println("La persona esta por encima de su peso ideal");
4                 break;
        }
3
    }
5
 
3     public static void MuestraMayorDeEdad(Persona p) {
6
 
3         if (p.esMayorDeEdad()) {
7             System.out.println("La persona es mayor de edad");
3         } else {
8             System.out.println("La persona no es mayor de edad");
3         }
    }
9
4  
}
0
4
1
4
2
4
3
4
4
4
5
4
6
4
7
4
8
4
9
5
0
5
1
5
2
5
3
5
4
5
5
5
6
5
7
5
8
5
9
6
0
6
1
6
2
6
3
6
4
6
5
6
6
6
7
6
8
6
9
7
0
7
1
7
2
7
3
7
4
7
5
7
6
7
7
7
8
–Clase ejecutable con Scanner
1 import java.util.Locale;
import java.util.Scanner;
2
import javax.swing.JOptionPane;
3
 
4 public class PersonaApp_Scanner {
5  
6     public static void main(String[] args) {
7  
8         Scanner sc = new Scanner(System.in);
9         sc.useDelimiter("n");
        sc.useLocale(Locale.US);
1
0          
        //Introducimos los datos
1
        System.out.println("Introduce el nombre");
1         String nombre = sc.next();
1  
2         System.out.println("Introduce la edad");
        int edad = sc.nextInt();
1
3  
        System.out.println("Introduce el sexo");
1         char sexo = sc.next().charAt(0);
4
 
1         System.out.println("Introduce el peso");
5         double peso = sc.nextDouble();
1  
6         System.out.println("Introduce la altura");
1         double altura = sc.nextDouble();
7  
1         //Creamos objetos con cada constructor
8         Persona persona1 = new Persona();
        Persona persona2 = new Persona(nombre, edad, sexo);
1
        Persona persona3 = new Persona(nombre, edad, sexo, peso, altura);
9
 
2         //Los datos que no esten completos los insertamos con los metodos set
0         persona1.setNombre("Laura");
2         persona1.setEdad(30);
1         persona1.setSexo('M');
2         persona1.setPeso(60);
2         persona1.setAltura(1.60);
2  
        persona2.setPeso(90.5);
3
        persona2.setAltura(1.80);
2
 
4         //Usamos metodos para realizar la misma accion para cada objeto
2         System.out.println("Persona1");
5         MuestraMensajePeso(persona1);
2         MuestraMayorDeEdad(persona1);
6         System.out.println(persona1.toString());
2  
7         System.out.println("Persona2");
        MuestraMensajePeso(persona2);
2
        MuestraMayorDeEdad(persona2);
8         System.out.println(persona2.toString());
2
 
9         System.out.println("Persona3");
3         MuestraMensajePeso(persona3);
0         MuestraMayorDeEdad(persona3);
3         System.out.println(persona3.toString());
1     }
3  
2     public static void MuestraMensajePeso(Persona p) {
        int IMC = p.calcularIMC();
3         switch (IMC) {
3             case Persona.PESO_IDEAL:
3                 System.out.println("La persona esta en su peso ideal");
4                 break;
3             case Persona.INFRAPESO:
5                 System.out.println("La persona esta por debajo de su peso ideal");
                break;
3
            case Persona.SOBREPESO:
6                 System.out.println("La persona esta por encima de su peso ideal");
3                 break;
7         }
3     }
8  
3     public static void MuestraMayorDeEdad(Persona p) {
9  
4         if (p.esMayorDeEdad()) {
            System.out.println("La persona es mayor de edad");
0
        } else {
4             System.out.println("La persona no es mayor de edad");
1         }
4     }
2  
4 }
3
4
4
4
5
4
6
4
7
4
8
4
9
5
0
5
1
5
2
5
3
5
4
5
5
5
6
5
7
5
8
5
9
6
0
6
1
6
2
6
3
6
4
6
5
6
6
6
7
6
8
6
9
7
0
7
1
7
2
7
3
7
4
7
5
7
6
7
7
7
8
7
9
8
0
8
1
8
2
8
3
8
4
8
5
3
Solucionado. La historia era por el “void” que tenía en el constructor con el parámetro longitud:
public void Password (int longitud){
this.longitud = longitud;
contraseña = generarPassword();
}

que en el constructor sin parámetro no lo tenía:

public Password(){
this.longitud = LONG_DEF;
}

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      */
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() {
        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 minuscula, mayuscula o numero
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));
                password+=minusculas;
58             }else{
59                 if(eleccion==2){
60                     char mayusculas=(char)((int)Math.floor(Math.random()*(91-65)+65));
61                     password+=mayusculas;
                }else{
62
                    char numeros=(char)((int)Math.floor(Math.random()*(58-48)+48));
63                     password+=numeros;
64                 }
65             }
66         }
        return password;
67
    }
68
  
69     /**
70      * Comprueba la fortaleza de la contraseña
71      * @return
72      */
    public boolean esFuerte(){
73
74         int cuentanumeros=0;
        int cuentaminusculas=0;
75
        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;
                }else{
80
                    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 2 mayusculas
87             if (cuentanumeros>=5 && cuentaminusculas>=1 && cuentamayusculas>=2){
88             return true;
89         }else{
            return false;
90
        }
91     }
92   
93     //Constructores
94     /**
95      * Crea una contraseña al azar
     */
96
    public Password (){
97         this(LONG_DEF);
98     }
99   
100     /**
101      * La contraseña sera la pasada por parametro
     * @param longitud
102
     */
103     public Password (int longitud){
104
105
106
107
108
109
110
111
112
113         this.longitud=longitud;
114         contraseña=generaPassword();
115     }
}
116
117
118
119
120
121
122
123
124
125
–Clase ejecutable
1 import javax.swing.JOptionPane;
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
  
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 fortaleza.
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()+" "+fortalezaPassword[i]);
21         }
    }
22
  
23
}
24
25

4
Clase Electrodomestico
1 /**
 * Clase Electrodomestico
2
3  *
 * Contiene informacion de los electrodomesticos
4
 * @author Fernando
5  * @version 1.0
6  */
7 public class Electrodomestico {
8    
9     //Constantes
10    
11     /**
     * Color por defecto
12      */
13     protected final static String COLOR_DEF="blanco";
14    
15     /**
16      * Consumo energetico por defecto
17      */
    protected final static char CONSUMO_ENERGETICO_DEF='F';
18
   
19     /**
20      * Precio base por defecto
21      */
22     protected final static double PRECIO_BASE_DEF=100;
23    
24     /**
     * Peso por defecto
25      */
26     protected final static double PESO_DEF=5;
27    
28     //Atributos
29    
30     /**
31      * El precio base del electrodomestico
     */
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{
            this.color=COLOR_DEF;
64
        }
65
          
66
          
67     }
68       
69     /**
70      * Comprueba el consumo energetico
71      * Solo mayusculas, si es una 'a' no lo detecta como una 'A'
72      * @param consumoEnergetico
     */
73     public void comprobarConsumoEnergetico(char consumoEnergetico){
74           
75         if(consumoEnergetico>=65 && consumoEnergetico<=70){
76             this.consumoEnergetico=consumoEnergetico;
77         }else{
78             this.consumoEnergetico=CONSUMO_ENERGETICO_DEF;
        }
79
          
80     }
81
   
82     //Métodos publicos
83     /**
84      * Devuelve el precio base del electrodomestico
85      * @return precio base del electrodomestico
     */
86
    public double getPrecioBase() {
87         return precioBase;
88     }
89     /**
90      * Devuelve el color del electrodomestico
     * @return color del elesctrodomestico
91      */
92     public String getColor() {
93         return color;
    }
94
95    
     /**
96      * Devuelve el consumo energetico del electrodomestico
97      * @return consumo energetico del electrodomestico
98      */
99     public char getConsumoEnergetico() {
        return consumoEnergetico;
100
    }
101     /**
102      * Devuelve el peso del electrodomestico
103      * @return peso del electrodomestico
104      */
    public double getPeso() {
105
        return peso;
106     }
107     /**
108      * Precio final del electrodomestico
109      * @return precio final del electrodomestico
     */
110
    public double precioFinal(){
111         double plus=0;
112         switch(consumoEnergetico){
113             case 'A':
114                 plus+=100;
                break;
115
            case 'B':
116                 plus+=80;
117                 break;
118             case 'C':
119                 plus+=60;
                break;
120
            case 'D':
121                 plus+=50;
122                 break;
123             case 'E':
                plus+=30;
124
                break;
125             case 'F':
126                 plus+=10;
127                 break;
128         }
129    
        if(peso>=0 && peso<19){
130
            plus+=10;
131         }else if(peso>=20 && peso<49){
132             plus+=50;
133         }else if(peso>=50 && peso<=79){
134             plus+=80;
        }else if(peso>=80){
135
            plus+=100;
136         }
137    
138         return precioBase+plus;
139     }
140    
141     //Constructores
142    
143     /**
     * Contructor por defecto
144      */
145     public Electrodomestico(){
146         this(PRECIO_BASE_DEF, PESO_DEF, CONSUMO_ENERGETICO_DEF, COLOR_DEF);
147     }
148    
149     /**
     * Contructor con 2 parametros
150      * @param precioBase del electrodomestico
151      * @param peso del electrodomestico
152      */
153     public Electrodomestico(double precioBase, double peso){
        this(precioBase, peso, CONSUMO_ENERGETICO_DEF, COLOR_DEF);
154
    }
155
   
156     /**
157      * Constructor con 4 parametros
158      * @param precioBase
159      * @param peso
     * @param consumoEnergetico
160
     * @param color
161      */
162     public Electrodomestico(double precioBase, double peso, char consumoEnergetico, String color){
163         this.precioBase=precioBase;
164         this.peso=peso;
        comprobarConsumoEnergetico(consumoEnergetico);
165
        comprobarColor(color);
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
196
–Clase Lavadora
1 /**
 * Clase Lavadora
2
 *
3  * Contiene informacion de lavador
4  *
5  * @author Fernando
6  * @version 1.0
 */
7
public class Lavadora extends Electrodomestico{
8
  
9     //Constantes
10   
11     /**
12      * Carga por defecto
13      */
14     private final static int CARGA_DEF=5;
15   
16     //Atributos
17   
18     /**
     * Carga de la lavadora
19      */
20     private int carga;
21   
22     //Métodos publicos
23   
24     /**
25      * Devuelve la carga de la lavadora
     * @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(){
35         //Invocamos el método precioFinal del método padre
36         double plus=super.precioFinal();
37   
        //añadimos el código necesario
38         if (carga>30){
39             plus+=50;
40         }
41   
42         return plus;
43     }
44   
    //Constructor
45
46   
47     /**
48      * Contructor por defecto
     */
49     public Lavadora(){
50         this(PRECIO_BASE_DEF, PESO_DEF, CONSUMO_ENERGETICO_DEF, COLOR_DEF, CARGA_DEF);
51     }
52   
53     /**
54      * Constructor con 2 parametros
     * @param precioBase
55      * @param peso
56      */
57     public Lavadora(double precioBase, double peso){
58         this(precioBase, peso, CONSUMO_ENERGETICO_DEF, COLOR_DEF, CARGA_DEF);
59     }
60   
    /**
61      * Constructor con 5 parametros
62      * @param precioBase
63      * @param peso
64      * @param consumoEnergetico
65      * @param color
     * @param carga
66      */
67     public Lavadora(double precioBase, double peso, char consumoEnergetico, String color, int carga){
68         super(precioBase,peso, consumoEnergetico,color);
69         this.carga=carga;
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  *
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
        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, RESOLUCION_DEF, false);
50     }
51   
52     /**
     * Constructor con 2 parametros
53
     * @param precioBase
54
55
56
57
58
59
60      * @param peso
61      */
    public Television(double precioBase, double peso){
62
        this(precioBase, peso, CONSUMO_ENERGETICO_DEF, COLOR_DEF, RESOLUCION_DEF, false);
63     }
64   
65     /**
66      * Contructor con 6 parametros
67      * @param precioBase
     * @param peso
68
     * @param consumoEnergetico
69      * @param color
70      * @param resolucion
71      * @param sintonizadorTDT
72      */
    public Television(double precioBase, double peso, char consumoEnergetico, String color, int resolucion, boolean sin
73
        super(precioBase, peso, consumoEnergetico, color);
74         this.resolucion=resolucion;
75         this.sintonizadorTDT=sintonizadorTDT;
76     }
77 }
78
79
80
81
82
83
–Clase Ejecutable
1 /**
 * Clase ejecutable
2
 * @author DiscoDurodeRoer
3  */
4 public class ElectrodomesticosApp {
5  
6     public static void main(String[] args) {
7    
8         //Creamos un array de Electrodomesticos
        Electrodomestico listaElectrodomesticos[]=new Electrodomestico[10];
9
10    
        //Asignamos cada una de las posiciones como queramos
11         listaElectrodomesticos[0]=new Electrodomestico(200, 60, 'C', "Verde");
12         listaElectrodomesticos[1]=new Lavadora(150, 30);
13         listaElectrodomesticos[2]=new Television(500, 80, 'E', "negro", 42, false);
14         listaElectrodomesticos[3]=new Electrodomestico();
15         listaElectrodomesticos[4]=new Electrodomestico(600, 20, 'D', "gris");
        listaElectrodomesticos[5]=new Lavadora(300, 40, 'Z', "blanco", 40);
16         listaElectrodomesticos[6]=new Television(250, 70);
17         listaElectrodomesticos[7]=new Lavadora(400, 100, 'A', "verde", 15);
18         listaElectrodomesticos[8]=new Television(200, 60, 'C', "naranja", 30, true);
19         listaElectrodomesticos[9]=new Electrodomestico(50, 10);
20    
21         //Creamos las variables que usaremos para almacenar la suma de los precios
        double sumaElectrodomesticos=0;
22         double sumaTelevisiones=0;
23         double sumaLavadoras=0;
24    
25         //Recorremos el array invocando el metodo precioFinal
26         for(int i=0;i<listaElectrodomesticos.length;i++){
27             /*
             * Cuando una Television o una Lavadora este en la posicion del array actual,
28              * pasara por su clase y por la de electrodomestico, ya que una television es un electrodomestico.
29              * Ejecutamos en cada uno su propia version del metodo precioFinal
30
31
32
33
34              */
35    
            if(listaElectrodomesticos[i] instanceof Electrodomestico){
36                 sumaElectrodomesticos+=listaElectrodomesticos[i].precioFinal();
37             }
38             if(listaElectrodomesticos[i] instanceof Lavadora){
39                 sumaLavadoras+=listaElectrodomesticos[i].precioFinal();
40             }
            if(listaElectrodomesticos[i] instanceof Television){
41                 sumaTelevisiones+=listaElectrodomesticos[i].precioFinal();
42             }
43         }
44    
45         //Mostramos los resultados
46         System.out.println("La suma del precio de los electrodomesticos es de "+sumaElectrodomesticos);
        System.out.println("La suma del precio de las lavadoras es de "+sumaLavadoras);
47         System.out.println("La suma del precio de las televisiones es de "+sumaTelevisiones);
48    
49     }
50    
51 }
52
53
54
55
5
–Clase Serie
1 /**
 * Clase Serie
2
 *
3  * Contiene informacion sobre una serie (en general)
4  * @author DiscoDurodeRoer
5  *
6  */
public class Serie implements Entregable{
7
  
8
    //Constantes
9
  
10     /**
11      * Numero de temporadas por defecto
12      */
13     private final static int NUM_TEMPORADAS_DEF=3;
14   
15     /**
     * Constante que indica que un objeto es mayor que otro
16      */
17     public final static int MAYOR=1;
18   
19     /**
20      * Constante que indica que un objeto es menor que otro
21      */
    public final static int MENOR=-1;
22
  
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     /**
54      * Devuelve el titulo de la serie
55      * @return titulo de la serie
56      */
    public String getTitulo() {
57
        return titulo;
58     }
59   
60     /**
61      * Modifica el titulo de la serie
62      * @param titulo a cambiar
     */
63
    public void setTitulo(String titulo) {
64         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
     * @param numeroTemporadas a cambiar
76      */
77     public void setnumeroTemporadas(int numeroTemporadas) {
78         this.numeroTemporadas = numeroTemporadas;
79     }
80   
81     /**
     * Devuelve el genero de la serie
82      * @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      */
98     public String getcreador() {
99         return creador;
    }
100
  
101     /**
102      * Modifica el creador de la serie
103      * @param creador a cambiar
104      */
105     public void setcreador(String creador) {
        this.creador = creador;
106     }
107   
108     /**
109      * Cambia el estado de entregado a true
110      */
111     public void entregar() {
        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 series segun su numero de temporadas
130      * @param objeto a comparar
131      * @return codigo numerico
132      * <ul>
133      * <li>1: La Serie 1 es mayor que la Serie 2</li>
     * <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) {
137         int estado=MENOR;
138   
139         //Hacemos un casting de objetos para usar el metodo get
140         Serie ref=(Serie)a;
        if (numeroTemporadas>ref.getnumeroTemporadas()){
141             estado=MAYOR;
142         }else if(numeroTemporadas==ref.getnumeroTemporadas()){
143             estado=IGUAL;
144         }
145   
146         return estado;
    }
147
148   
    /**
149      * Muestra informacion de la Serie
150      * @return cadena con toda la informacion de la Serie
151      */
152     public String toString(){
        return "Informacion de la Serie: n" +
153
                "tTitulo: "+titulo+"n" +
154                 "tNumero de temporadas: "+numeroTemporadas+"n" +
155                 "tGenero: "+genero+"n" +
156                 "tCreador: "+creador;
157     }
158   
159     /**
     * Indica si dos Series son iguales, siendo el titulo y creador iguales
160      * @param a Serie a comparar
161      * @return true si son iguales y false si son distintos
162      */
163     public boolean equals(Serie a){
        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     /**
178      * Contructor con 2 parametros
     * @param titulo de la Serie
179      * @param creador de la Serie
180      */
181     public Serie(String titulo, String creador){
182         this(titulo,NUM_TEMPORADAS_DEF, "", creador);
    }
183
184   
    /**
185      * Constructor con 4 parametros
186      * @param titulo de la Serie
187      * @param numeroTemporadas de la Serie
188      * @param genero de la Serie
189      * @param creador de la Serie
     */
190     public Serie(String titulo, int numeroTemporadas, String genero, String creador){
191         this.titulo=titulo;
192         this.numeroTemporadas=numeroTemporadas;
193         this.genero=genero;
        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
–Clase Videojuego
1 /**
 *
2
 * Clase videojuego
3  *
4  * Contiene la informacion sobre un videojuego
5  *
6  * @author DiscoDurodeRoer
 */
7
public class Videojuego implements Entregable{
8
  
9     //Constantes
10   
11     /**
12      * Horas estimadas por defecto
13      */
14     private final static int HORAS_ESTIMADAS_DEF=100;
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   
    //Atributos
29
  
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     /**
49      * Compañia del videojuego
50      */
    private String compañia;
51
  
52     //Métodos publicos
53   
54     /**
55      * Devuelve el titulo del videojuego
56      * @return titulo del videojuego
57      */
    public String getTitulo() {
58         return titulo;
59     }
60   
61     /**
62      * Modifica el titulo del videojuego
63      * @param titulo a cambiar
     */
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 horasEstimadas
77      */
78     public void setHorasEstimadas(int horasEstimadas) {
79         this.horasEstimadas = horasEstimadas;
    }
80
  
81     /**
82      * Devuelve el genero del videojuego
83      * @return genero del videojuego
84      */
85     public String getGenero() {
        return genero;
86     }
87   
88     /**
89      * Modifica el genero del videojuego
90      * @param genero a cambiar
91      */
    public void setGenero(String genero) {
92         this.genero = genero;
93     }
94   
95     /**
96      * Devuelve el compañia del videojuego
     * @return compañia del videojuego
97
     */
98     public String getcompañia() {
99         return compañia;
100     }
101   
102     /**
     * Modifica el compañia del videojuego
103
     * @param compañia a cambiar
104      */
105     public void setcompañia(String compañia) {
106         this.compañia = compañia;
107     }
108   
109     /**
     * Cambia el estado de entregado a true
110      */
111     @Override
112     public void entregar() {
113         entregado=true;
    }
114
115   
    /**
116      * Cambia el estado de entregado a false
117      */
118     @Override
119     public void devolver() {
120         entregado=false;
    }
121
  
122     /**
123      * Indica el estado de entregado
124      * @return
125      */
126     @Override
    public boolean isEntregado() {
127
        if(entregado){
128             return true;
129         }
130         return false;
131     }
132   
    /**
133
     * Compara dos videojuegos segun el numero de paginas
134      * @return codigo numerico
135      * <ul>
136      * <li>1: El videojuego 1 es mayor que el videojuego 2</li>
137      * <li>0: Los videojuegos son iguales</li>
     * <li>-1: El videojuego 1 es menor que el videojuego 2</li></ul>
138
     */
139     @Override
140     public int compareTo(Object a) {
141         int estado=MENOR;
142   
143         //Hacemos un casting de objetos para usar el metodo get
        Videojuego ref=(Videojuego)a;
144
        if (horasEstimadas>ref.getHorasEstimadas()){
145             estado=MAYOR;
146         }else if(horasEstimadas==ref.getHorasEstimadas()){
147             estado=IGUAL;
148         }
149   
150         return estado;
    }
151
  
152     /**
153      * Muestra informacion del videojuego
154      * @return cadena con toda la informacion del videojuego
155      */
156     @Override
    public String toString(){
157
        return "Informacion del videojuego: n" +
158                 "tTitulo: "+titulo+"n" +
159                 "tHoras estimadas: "+horasEstimadas+"n" +
160                 "tGenero: "+genero+"n" +
161                 "tcompañia: "+compañia;
    }
162
  
163
    /**
164      * Indica si dos videojuegos son iguales, siendo el titulo y compañia iguales
165      * @param a videojuego a comparar
166      * @return true si son iguales y false si son distintos
167      */
    public boolean equals(Videojuego a){
168
        if (titulo.equalsIgnoreCase(a.getTitulo()) && compañia.equalsIgnoreCase(a.getcompañia())){
169             return true;
170         }
171         return false;
172     }
173   
    //Constructor
174
175   
    /**
176      * Constructo por defecto
177      */
178     public Videojuego(){
179         this("",HORAS_ESTIMADAS_DEF, "", "");
180     }
181   
    /**
182      * Constructor con 2 parametros
183      * @param titulo del videojuego
184      * @param compañia del videojuego
185      */
186     public Videojuego(String titulo, String compañia){
        this(titulo,HORAS_ESTIMADAS_DEF, "", compañia);
187
    }
188
  
189     /**
190      * Constructor con 4 parametros
191      * @param titulo del videojuego
192      * @param horasEstimadas
     * @param genero del videojuego
193
     * @param compañia del videojuego
194      */
195     public Videojuego(String titulo, int horasEstimadas, String genero, String compañia){
196         this.titulo=titulo;
197         this.horasEstimadas=horasEstimadas;
        this.genero=genero;
198
        this.compañia=compañia;
199         this.entregado=false;
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
232
233
234
235
236
–Interfaz Entregable
1 public interface Entregable {
2   
3     public void entregar();
4   
    public void devolver();
5
  
6     public boolean isEntregado();
7   
8     public int compareTo(Object a);
9 }
10
–Clase ejecutable
1 public class EntregablesApp {
2   
3     public static void main(String[] args) {
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();
10         listaSeries[1]=new Serie("Juego de tronos", "George R. R. Martin ");
        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");
16         listaVideojuegos[2]=new Videojuego("God of war 3", "Santa Monica");
        listaVideojuegos[3]=new Videojuego("Super Mario 3DS", 30, "Plataforma", "Nintendo");
17         listaVideojuegos[4]=new Videojuego("Final fantasy X", 200, "Rol", "Square Enix");
18   
19         //entregamos algunos videojuegos y series
20         listaSeries[1].entregar();
21         listaSeries[4].entregar();
22         listaVideojuegos[0].entregar();
        listaVideojuegos[3].entregar();
23
  
24
        //Recorremos los arrays para contar cuantos entregados hay, tambien los devolvemos
25
  
26         int entregados=0;
27   
28         for(int i=0;i<listaSeries.length;i++){
            if(listaSeries[i].isEntregado()){
29
                entregados+=1;
30                 listaSeries[i].devolver();
31   
32             }
33             if(listaVideojuegos[i].isEntregado()){
34                 entregados+=1;
                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
41         Serie serieMayor=listaSeries[0];
42         Videojuego videojuegoMayor=listaVideojuegos[0];
43   
        //Recorremos el array desde la posicion 1 (no 0), comparando el mayor con las posiciones del array
44         for(int i=1;i<listaSeries.length;i++){
45             if(listaSeries[i].compareTo(serieMayor)==Serie.MAYOR){
46                 serieMayor=listaSeries[i];
47             }
48             if(listaVideojuegos[i].compareTo(videojuegoMayor)==Videojuego.MAYOR){
                videojuegoMayor=listaVideojuegos[i];
49             }
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

6
–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;
        titulo=pTitulo;
12
        autor=pAutor;
13         numPaginas=pNumPaginas;
14      
15     }
16      
17     /*Metodos*/
18  
19     public int getISBN() {
20         return ISBN;
    }
21
 
22     public void setISBN(int ISBN) {
23         this.ISBN = ISBN;
24     }
25  
26     public String getTitulo() {
27         return titulo;
    }
28
 
29     public void setTitulo(String titulo) {
30         this.titulo = titulo;
31     }
32  
33     public String getAutor() {
34         return autor;
    }
35
 
36     public void setAutor(String autor) {
37         this.autor = autor;
38     }
39  
40     public int getNumPaginas() {
41
42
43
44
45         return numPaginas;
    }
46
47  
    public void setNumPaginas(int numPaginas) {
48         this.numPaginas = numPaginas;
49     }
50      
51     @Override
52     public String toString(){
        return "El libro "+titulo+" con ISBN "+ISBN+""
53
                + " creado por el autor "+autor
54                 + " tiene "+numPaginas+" páginas";
55     }
56      
57      
58      
59 }
60
61
62
63
–Clase principal
1 public class Ejercicio_POO_DDR_1 {
2  
    public static void main(String[] args) {
3
4         
        //Creamos lo objetos
5         Libro libro1=new Libro(1111111111, "titulo1", "autor1", 30);
6
7
        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
27
7
— 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", "Eustaquio"};
10     private final String[] NOMBRES_CHICAS={"Alicia", "Laura", "Clotilde", "Pepa", "Elena"};
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
        disponibilidad();
28
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) {
44         this.nombre = 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     /**
62      * Devuelve la edad de la persona
63      * @return
     */
64
    public int getEdad() {
65         return edad;
66     }
67  
68     /**
69      * Modifica la edad de la edad
     * @param edad
70
     */
71     public void setEdad(int edad) {
72         this.edad = edad;
73     }
74  
75     /**
     * Indica la asistencia de la persona
76
     * @return
77      */
78     public boolean isAsistencia() {
79         return asistencia;
80     }
81  
    /**
82
     * Modifica la asistencia de la persona
83      * @param asistencia
84      */
85     public void setAsistencia(boolean asistencia) {
86         this.asistencia = asistencia;
87
88
89
90
91
92
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          
        nota=MetodosSueltos.generaNumeroAleatorio(0,10);
10          
11         super.setEdad(MetodosSueltos.generaNumeroAleatorio(12,15));
12          
13     }
14  
    /*Metodos*/
15
     
16     /**
17      * Devuelve la nota
18      * @return nota del alumno
19      */
20      
21     public int getNota() {
        return nota;
22     }
23
 
24     /**
25      * Modifica la nota del alumno
26      * @param nota
27      */
    public void setNota(int nota) {
28         this.nota = nota;
29     }
30  
31     /**
32      * Indica si el alumno esta disponible (50%)
33      */
    @Override
34     public void disponibilidad() {
35
         
36         int prob=MetodosSueltos.generaNumeroAleatorio(0, 100);
37          
38         if(prob<50){
39             super.setAsistencia(false);
40
41
42
43
44         }else{
            super.setAsistencia(true);
45         }
46          
47     }
48      
49     /**
50      * Muestra la informacion del alumno
51      * @return informacion
     */
52
    public String toString(){
53
         
54         return "Nombre: "+super.getNombre()+" ,sexo: "+super.getSexo()+" , nota: "+nota;
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*/
    private String materia;
4
5     
    /*Constructores*/
6     public Profesor(){
7        super(); //Llama al constructor padre
8         
9        super.setEdad(MetodosSueltos.generaNumeroAleatorio(25,50)); //llama al metodo padre
10         
11        materia=Constantes.MATERIAS[MetodosSueltos.generaNumeroAleatorio(0,2)];
12     }
13  
    /*Metodos*/
14
     
15     /**
16      * Devuelve la materia del profesor
17      * @return
18      */
19     public String getMateria() {
        return materia;
20     }
21
 
22     /**
23      * Modifica la materia del profesor
24      * @param materia
25      */
    public void setMateria(String materia) {
26         this.materia = materia;
27     }
28  
29     /**
30      * Calcula la disponibilidad del profesor(20%)
31      */
    @Override
32
33
34
35
36     public void disponibilidad() {
37         
38         int prob=MetodosSueltos.generaNumeroAleatorio(0, 100);
39          
40         if(prob<20){
            super.setAsistencia(false);
41         }else{
42             super.setAsistencia(true);
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          
        profesor=new Profesor();
15         alumnos= new Alumno[MAX_ALUMNOS];
16         creaAlumnos();
17         materia=Constantes.MATERIAS[MetodosSueltos.generaNumeroAleatorio(0,2)];
18          
19     }
20      
21     /*Metodos*/
22      
    /**
23
     * Crea los alumnos para el aula
24      */
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      * Indica si la asistencia de los alumnos es mayor del 50%
35      * @return
36      */
37     private boolean asistenciaAlumnos(){
38          
        int cuentaAsistencias=0;
39
         
40
41         //contamos las asistencias
        for(int i=0;i<alumnos.length;i++){
42
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      */
    public boolean darClase(){
59
         
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, no se puede dar clase");
            return false;
67         }else if (!asistenciaAlumnos()){
68             System.out.println("La asistencia no es suficiente, no se puede dar clase");
69             return false;
70         }
71          
72         System.out.println("Se puede dar clase");
73         return true;
74          
    }
75
     
76     /**
77      * Indicamos las notas de los alumnos aprobados, chicos y chicas
78      */
79     public void notas(){
80          
81         int chicosApro=0;
        int chicasApro=0;
82
         
83
         for(int i=0;i<alumnos.length;i++){
84
            
85            //Comprobamos si el alumno esta aprobado
86            if(alumnos[i].getNota()>=5){
87                //Segun el sexo, aumentara uno o otro
88                if(alumnos[i].getSexo()=='H'){
                   chicosApro++;
89
               }else{
90                    chicasApro++;
91                }
92                 
93                System.out.println(alumnos[i].toString());
94                 
95            }
96              
97         }
98           
        System.out.println("Hay "+chicosApro+" chicos y "+chicasApro+" chicas aprobados/as");
99
         
100
101
102
103
104
105
106
107     }
108      
109 }
110
111
112
113
114
115
— Clase Constantes
1 //Clase constantes
2 public class Constantes {
3      
4     public static final String[] MATERIAS={"Matematicas", "Filosofia", "Fisica"};
5      
6 }

— Clase MetodosSueltos
1 public class MetodosSueltos {
2      
3     /**
     * Genera un numero aleatorio entre dos numeros.
4      * Entre el minimo y el maximo
5      * @param minimo
6      * @param maximo
7
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  
    public static void main(String[] args) {
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
— 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  
11     /*Constructores*/
12     public Espectador(String nombre, int edad, double dinero) {
13         this.nombre = nombre;
        this.edad = edad;
14
        this.dinero = dinero;
15     }
16  
17     /*Metodos*/
18     public String getNombre() {
19         return nombre;
    }
20
21  
    public void setNombre(String nombre) {
22         this.nombre = nombre;
23     }
24  
25     public int getEdad() {
        return edad;
26
    }
27
 
28     public void setEdad(int edad) {
29         this.edad = edad;
30     }
31  
32     public double getDinero() {
        return dinero;
33
    }
34
 
35     public void setDinero(double dinero) {
36         this.dinero = dinero;
37     }
38  
39     /**
     * Pagamos la entrada del cine
40
     *
41      * @param precio
42      */
43     public void pagar(double precio) {
44         dinero -= precio;
    }
45
46  
    /**
47      * Indicamos si el espectador tiene edad para ver la pelicula (en el video
48      * estaba en la clase pelicula tiene mas sentido que sea un metodo del
49      * espectador)
50      *
     * @param edadMinima
51
     * @return
52      */
53     public boolean tieneEdad(int edadMinima) {
54
55
56
57
58
59
60         return edad >= edadMinima;
    }
61
 
62     /**
63      * Indicamos si el espectador tiene dinero (en el video estaba en la clase
64      * cine tiene mas sentido que sea un metodo del espectador)
65      *
66      * @param precioEntrada
     * @return
67      */
68     public boolean tieneDinero(double precioEntrada) {
69         return dinero >= precioEntrada;
70     }
71  
72     @Override
    public String toString() {
73         return "el nombre del espectador es " + nombre + " de " + edad + " años y con " + dinero + " euros en su bol
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
 *
3  * @author DiscoDurodeRoer
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, null si es vacio
10  
11     /*Constructores*/
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         return fila;
    }
27
28  
    public void setFila(int fila) {
29         this.fila = fila;
30     }
31  
32     public Espectador getEspectador() {
        return espectador;
33
    }
34
 
35     public void setEspectador(Espectador espectador) {
36         this.espectador = espectador;
37     }
38  
39     /**
     * Indica si el asiento esta ocupado
40
     *
41      * @return
42      */
43     public boolean ocupado() {
44         return espectador != null;
    }
45
46  
    @Override
47     public String toString() {
48         if (ocupado()) {
49             return "Asiento: " + fila + letra + " y " + espectador;
50         }
51  
        return "Asiento: " + fila + letra + " y este asiento está vacio ";
52
53  
    }
54
 
55 }
56
57
58
59
60
61
62
63
64
— Clase Pelicula
1 /**
 * Clase Pelicula, lleva todo lo relacionado con la pelicula
2
 *
3  * @author DiscoDurodeRoer
4  */
5 public class Pelicula {
6  
7     /*Atributos*/
    private String titulo;
8
    private int duracion;
9     private int edadMinima;
1     private String director;
0  
1     /*Constructor*/
1     public Pelicula(String titulo, int duracion, int edadMinima, String director) {
1         this.titulo = titulo;
        this.duracion = duracion;
2
        this.edadMinima = edadMinima;
1         this.director = director;
3     }
1  
4     /*Metodos*/
1     public String getTitulo() {
5         return titulo;
    }
1
6  
    public void setTitulo(String titulo) {
1         this.titulo = titulo;
7     }
1  
8     public int getDuracion() {
1         return duracion;
    }
9
2  
    public void setDuracion(int duracion) {
0         this.duracion = duracion;
2     }
1  
2     public int getEdadMinima() {
2         return edadMinima;
2     }
3  
    public void setEdadMinima(int edadMinima) {
2
        this.edadMinima = edadMinima;
4     }
2  
5     public String getDirector() {
2         return director;
6     }
2  
7     public void setDirector(String director) {
2         this.director = director;
    }
8
2  
    @Override
9     public String toString() {
3         return "'" + titulo + "' del director " + director + ", con una duracion de " + duracion + " minutos y la edad mi
0     }
3  
1 }
3
2
3
3
3
4
3
5
3
6
3
7
3
8
3
9
4
0
4
1
4
2
4
3
4
4
4
5
4
6
4
7
4
8
4
9
5
0
5
1
5
2
5
3
5
4
5
5
5
6
5
7
5
8
5
9
6
0
— Clase Cine
1 /**
 * Clase Cine, lleva todo lo relativo al cine
2
 *
3  * @author DiscoDurodeRoer
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  
34     public Pelicula getPelicula() {
        return pelicula;
35
36     }
37  
    public void setPelicula(Pelicula pelicula) {
38
        this.pelicula = pelicula;
39     }
40  
41     /**
42      * Rellena nuestros asientos, dandoles una fila y una letra
43      */
    private void rellenaButacas() {
44
45  
        int fila = asientos.length;
46         for (int i = 0; i < asientos.length; i++) {
47             for (int j = 0; j < asientos[0].length; j++) {
48                 //Recuerda que los char se pueden sumar
49                 asientos[i][j] = new Asiento((char) ('A' + j), fila);
            }
50
            fila--; //Decremento la fila para actualizar la fila
51         }
52  
53     }
54  
55     /**
56      * Indicamos si hay sitio en el cine, cuando vemos una vacia salimos de la
     * función
57
     *
58      * @return
59      */
60     public boolean haySitio() {
61  
62         for (int i = 0; i < asientos.length; i++) {
            for (int j = 0; j < asientos[0].length; j++) {
63
64  
                if (!asientos[i][j].ocupado()) {
65
66                     return true;
                }
67
68  
            }
69         }
70  
71         return false;
72     }
73  
74     /**
     * Indico si en una posicion concreta esta ocupada
75
     *
76      * @param fila
77      * @param letra
78      * @return
79      */
    public boolean haySitioButaca(int fila, char letra) {
80
        return getAsiento(fila, letra).ocupado();
81     }
82  
83     /**
84      * Indicamos si el espectador cumple lo necesario para entrar: - Tiene
85      * dinero - Tiene edad El tema de si hay sitio, se controla en el main
     *
86
     * @param e
87      * @return
88      */
89     public boolean sePuedeSentar(Espectador e) {
90         return e.tieneDinero(precio) && e.tieneEdad(pelicula.getEdadMinima());
    }
91
92  
    /**
93      * Siento al espectador en un asiento
94      *
95      * @param fila
96      * @param letra
     * @param e
97
     */
98     public void sentar(int fila, char letra, Espectador e) {
99         getAsiento(fila, letra).setEspectador(e);
100     }
101  
102     /**
     * Devuelvo un asiento concreto por su fila y letra
103
     *
104      * @param fila
105      * @param letra
106      * @return
107      */
    public Asiento getAsiento(int fila, char letra) {
108
        return asientos[asientos.length - fila - 1][letra - 'A'];
109     }
110  
111     /**
112      * Numero de filas de nuestro cine
113      *
     * @return
114
     */
115     public int getFilas() {
116         return asientos.length;
117     }
118  
119     /**
     * Numero de columas de nuestro cine
120
     *
121      * @return
122      */
123     public int getColumnas() {
124         return asientos[0].length;
    }
125
126  
127     /**
     * Mostramos la información de nuestro cine (Tambien se puede hacer en un
128
     * toString pero hay que devolver un String)
129      */
130     public void mostrar() {
131  
132         System.out.println("Información cine");
133         System.out.println("Pelicula reproducida: " + pelicula);
        System.out.println("Precio entrada: " + precio);
134
        System.out.println("");
135         for (int i = 0; i < asientos.length; i++) {
136             for (int j = 0; j < asientos[0].length; j++) {
137                 System.out.println(asientos[i][j]);
138             }
            System.out.println("");
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
4  * @author DiscoDurodeRoer
 */
5
public class Principal {
6
 
7     public static void main(String[] args) {
8  
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)
        Scanner sn = new Scanner(System.in);
14
         
15         System.out.println("Introduce el numero de filas");
16         int filas=sn.nextInt();
17          
18         System.out.println("Introduce el numero de columnas");
19         int columnas=sn.nextInt();
20          
21         System.out.println("Introduce el precio de la entrada de cine");
        double precio=sn.nextDouble();
22
         
23
        //Creo el cine, necesito la pelicula para ello
24         Cine cine = new Cine(filas, columnas, precio, pelicula);
25  
26         //Numero de espectadores que seran creados
27         System.out.println("Introduce el numero de espectadores a crear");
28         int numEspectadores = sn.nextInt();
29  
        //Variables y objetos usados
30
        Espectador e;
31         int fila;
32         char letra;
33  
34         System.out.println("Espectadores generados: ");
        //Termino cuando no queden espectadores o no haya mas sitio en el cine
35
        for (int i = 0; i < numEspectadores &amp;&amp; cine.haySitio(); i++) {
36
 
37             //Generamos un espectador
38             e = new Espectador(
39                     Metodos.nombres[Metodos.generaNumeroEnteroAleatorio(0, Metodos.nombres.length - 1)], //Nombre
40                     Metodos.generaNumeroEnteroAleatorio(10, 30), //Generamos una edad entre 10 y 30
                    Metodos.generaNumeroEnteroAleatorio(1, 10)); //Generamos el dinero entre 1 y 10 euros
41
42  
            //Mostramos la informacion del espectador
43             System.out.println(e);
44              
45             //Generamos una fila y letra
46             //Si esta libre continua sino busca de nuevo
47             do {
48  
                fila = Metodos.generaNumeroEnteroAleatorio(0, cine.getFilas() - 1);
49
                letra = (char) Metodos.generaNumeroEnteroAleatorio('A', 'A' + (cine.getColumnas()-1));
50
 
51             } while (cine.haySitioButaca(fila, letra));
52  
53             //Si el espectador cumple con las condiciones
54             if (cine.sePuedeSentar(e)) {
55                 e.pagar(cine.getPrecio()); //El espectador paga el precio de la entrada
                cine.sentar(fila, letra, e); //El espectador se sienta
56
            }
57
 
58         }
59  
60         System.out.println("");
61         cine.mostrar(); //Mostramos la información del cine, tambien se puede usar un toString
62          
63         System.out.println("Fin");
64
65
66
67
68
69  
    }
70
 
71 }
72
73
74
75
76

https://www.discoduroderoer.es/ejercicios-propuestos-y-resueltos-programacion-orientado-a-objetos-java/