Ejercicios propuestos y resueltos programación orientado a objetos Java

–Clase Cuenta

/**
 * Clase Cuenta
 * @author DiscoDurodeRoer
 */
public class Cuenta {

    //Atributos
    private String titular;
    private double cantidad;

    //Constructores
    public Cuenta(String titular) {
        this(titular, 0); //Sobrecarga
    }

    public Cuenta(String titular, double cantidad) {
        this.titular = titular;
        //Si la cantidad es menor que cero, lo ponemos a cero
        if (cantidad < 0) {
            this.cantidad = 0;
        } else {
            this.cantidad = cantidad;
        }
    }

    //Metodos
    public String getTitular() {
        return titular;
    }

    public void setTitular(String titular) {
        this.titular = titular;
    }

    public double getCantidad() {
        return cantidad;
    }

    public void setCantidad(double cantidad) {
        this.cantidad = cantidad;
    }

    /**
     * Ingresa dinero en la cuenta, 
     * solo si es positivo la cantidad
     *
     * @param cantidad
     */
    public void ingresar(double cantidad) {
        if(cantidad > 0){
            this.cantidad += cantidad;   
        }
    }

    /**
     * Retira una cantidad en la cuenta, si se quedara en negativo se quedaria
     * en cero
     *
     * @param cantidad
     */
    public void retirar(double cantidad) {
        if (this.cantidad - cantidad < 0) {
            this.cantidad = 0;
        } else {
            this.cantidad -= cantidad;
        }
    }

    /**
     * Devuelve el estado del objeto
     *
     * @return
     */
    @Override
    public String toString() {
        return "El titular " + titular + " tiene " + cantidad + " euros en la cuenta";
    }

}

–Clase ejecutable

public class CuentaApp {

    public static void main(String[] args) {
        
        Cuenta cuenta_1 = new Cuenta("DiscoDurodeRoer");
        Cuenta cuenta_2 = new Cuenta("Fernando", 300);
        
        //Ingresa dinero en las cuentas
        cuenta_1.ingresar(300);
        cuenta_2.ingresar(400);
        
        //Retiramos dinero en las cuentas
        cuenta_1.retirar(500);
        cuenta_2.retirar(100);
        
        //Muestro la informacion de las cuentas
        System.out.println(cuenta_1); // 0 euros
        System.out.println(cuenta_2); // 600 euros
        
    }
    
}

/**
 * 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ños\n"
                + "DNI: " + DNI + "\n"
                + "Peso: " + peso + " kg\n"
                + "Altura: " + altura + " metros\n";
    }

}

–Clase ejecutable con JOptionPane

import javax.swing.JOptionPane;

public class PersonaApp {

    public static void main(String[] args) {

        //Introducimos los datos
        String nombre = JOptionPane.showInputDialog("Introduce el nombre");

        String texto = JOptionPane.showInputDialog("Introduce la edad");
        int edad = Integer.parseInt(texto);

        texto = JOptionPane.showInputDialog("Introduce el sexo");
        char sexo = texto.charAt(0);

        texto = JOptionPane.showInputDialog("Introduce el peso");
        double peso = Double.parseDouble(texto);

        texto = JOptionPane.showInputDialog("Introduce la altura");
        double altura = Double.parseDouble(texto);

        //Creamos objetos con cada constructor
        Persona persona1 = new Persona();
        Persona persona2 = new Persona(nombre, edad, sexo);
        Persona persona3 = new Persona(nombre, edad, sexo, peso, altura);

        //Los datos que no esten completos los insertamos con los metodos set
        persona1.setNombre("Laura");
        persona1.setEdad(30);
        persona1.setSexo('M');
        persona1.setPeso(60);
        persona1.setAltura(1.60);

        persona2.setPeso(90.5);
        persona2.setAltura(1.80);

        //Usamos metodos para realizar la misma accion para cada objeto
        System.out.println("Persona1");
        MuestraMensajePeso(persona1);
        MuestraMayorDeEdad(persona1);
        System.out.println(persona1.toString());

        System.out.println("Persona2");
        MuestraMensajePeso(persona2);
        MuestraMayorDeEdad(persona2);
        System.out.println(persona2.toString());

        System.out.println("Persona3");
        MuestraMensajePeso(persona3);
        MuestraMayorDeEdad(persona3);
        System.out.println(persona3.toString());
    }

    public static void MuestraMensajePeso(Persona p) {
        int IMC = p.calcularIMC();
        switch (IMC) {
            case Persona.PESO_IDEAL:
                System.out.println("La persona esta en su peso ideal");
                break;
            case Persona.INFRAPESO:
                System.out.println("La persona esta por debajo de su peso ideal");
                break;
            case Persona.SOBREPESO:
                System.out.println("La persona esta por encima de su peso ideal");
                break;
        }
    }

    public static void MuestraMayorDeEdad(Persona p) {

        if (p.esMayorDeEdad()) {
            System.out.println("La persona es mayor de edad");
        } else {
            System.out.println("La persona no es mayor de edad");
        }
    }

}

–Clase ejecutable con Scanner

import java.util.Locale;
import java.util.Scanner;
import javax.swing.JOptionPane;

public class PersonaApp_Scanner {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        sc.useDelimiter("\n");
        sc.useLocale(Locale.US);
        
        //Introducimos los datos
        System.out.println("Introduce el nombre");
        String nombre = sc.next();

        System.out.println("Introduce la edad");
        int edad = sc.nextInt();

        System.out.println("Introduce el sexo");
        char sexo = sc.next().charAt(0);

        System.out.println("Introduce el peso");
        double peso = sc.nextDouble();

        System.out.println("Introduce la altura");
        double altura = sc.nextDouble();

        //Creamos objetos con cada constructor
        Persona persona1 = new Persona();
        Persona persona2 = new Persona(nombre, edad, sexo);
        Persona persona3 = new Persona(nombre, edad, sexo, peso, altura);

        //Los datos que no esten completos los insertamos con los metodos set
        persona1.setNombre("Laura");
        persona1.setEdad(30);
        persona1.setSexo('M');
        persona1.setPeso(60);
        persona1.setAltura(1.60);

        persona2.setPeso(90.5);
        persona2.setAltura(1.80);

        //Usamos metodos para realizar la misma accion para cada objeto
        System.out.println("Persona1");
        MuestraMensajePeso(persona1);
        MuestraMayorDeEdad(persona1);
        System.out.println(persona1.toString());

        System.out.println("Persona2");
        MuestraMensajePeso(persona2);
        MuestraMayorDeEdad(persona2);
        System.out.println(persona2.toString());

        System.out.println("Persona3");
        MuestraMensajePeso(persona3);
        MuestraMayorDeEdad(persona3);
        System.out.println(persona3.toString());
    }

    public static void MuestraMensajePeso(Persona p) {
        int IMC = p.calcularIMC();
        switch (IMC) {
            case Persona.PESO_IDEAL:
                System.out.println("La persona esta en su peso ideal");
                break;
            case Persona.INFRAPESO:
                System.out.println("La persona esta por debajo de su peso ideal");
                break;
            case Persona.SOBREPESO:
                System.out.println("La persona esta por encima de su peso ideal");
                break;
        }
    }

    public static void MuestraMayorDeEdad(Persona p) {

        if (p.esMayorDeEdad()) {
            System.out.println("La persona es mayor de edad");
        } else {
            System.out.println("La persona no es mayor de edad");
        }
    }

}

/**
 * Clase Password
 *
 * Contiene una contraseña y una longitud
 *
 * @author Fernando
 * @version 1.0
 */
public class Password {
 
    //Constantes
 
    /**
     * Longitud por defecto
     */
    private final static int LONG_DEF=8;
 
    //Atributos
 
    /**
     * Longitud de la contraseña
     */
    private int longitud;
    /**
     * caracteres de la contraseña
     */
    private String contraseña;
 
    //Metodos publicos
 
    /**
     * Devuelve la longitud
     * @return longitud de la contraseña
     */
    public int getLongitud() {
        return longitud;
    }
 
    /**
     * Modifica la longitud de la contraseña
     * @param longitud a cambiar
     */
    public void setLongitud(int longitud) {
        this.longitud = longitud;
    }
 
    /**
     * Devuelve la contraseña
     * @return contraseña
     */
    public String getContraseña() {
        return contraseña;
    }
 
    /**
     * Genera una contraseña al azar con la longitud que este definida
     * @return contraseña
     */
    public String generaPassword (){
        String password="";
        for (int i=0;i<longitud;i++){
            //Generamos un numero aleatorio, segun este elige si añadir una minuscula, mayuscula o numero
            int eleccion=((int)Math.floor(Math.random()*3+1));
 
            if (eleccion==1){
                char minusculas=(char)((int)Math.floor(Math.random()*(123-97)+97));
                password+=minusculas;
            }else{
                if(eleccion==2){
                    char mayusculas=(char)((int)Math.floor(Math.random()*(91-65)+65));
                    password+=mayusculas;
                }else{
                    char numeros=(char)((int)Math.floor(Math.random()*(58-48)+48));
                    password+=numeros;
                }
            }
        }
        return password;
    }
 
    /**
     * Comprueba la fortaleza de la contraseña
     * @return
     */
    public boolean esFuerte(){
        int cuentanumeros=0;
        int cuentaminusculas=0;
        int cuentamayusculas=0;
        //Vamos caracter a caracter y comprobamos que tipo de caracter es
        for (int i=0;i<contraseña.length();i++){
                if (contraseña.charAt(i)>=97 && contraseña.charAt(i)<=122){
                    cuentaminusculas+=1;
                }else{
                    if (contraseña.charAt(i)>=65 && contraseña.charAt(i)<=90){
                        cuentamayusculas+=1;
                }else{
                    cuentanumeros+=1;
                    }
                }
            }
            //Si la constraseña tiene mas de 5 numeros, mas de 1 minuscula y mas de 2 mayusculas
            if (cuentanumeros>=5 && cuentaminusculas>=1 && cuentamayusculas>=2){
            return true;
        }else{
            return false;
        }
    }
 
    //Constructores
    /**
     * Crea una contraseña al azar
     */
    public Password (){
        this(LONG_DEF);
    }
 
    /**
     * La contraseña sera la pasada por parametro
     * @param longitud
     */
    public Password (int longitud){
        this.longitud=longitud;
        contraseña=generaPassword();
    }
}

–Clase ejecutable

import javax.swing.JOptionPane;
public class PasswordApp {
 
    public static void main(String[] args) {
 
        //Introducimos el tamaño del array y la longitud del password
        String texto=JOptionPane.showInputDialog("Introduce un tamaño para el array");
        int tamanio=Integer.parseInt(texto);
 
        texto=JOptionPane.showInputDialog("Introduce la longitud del password");
        int longitud=Integer.parseInt(texto);
 
        //Creamos los arrays
        Password listaPassword[]=new Password[tamanio];
        boolean fortalezaPassword[]=new boolean[tamanio];
 
        //Creamos objetos, indicamos si es fuerte y mostramos la contraseña y su fortaleza.
        for(int i=0;i<listaPassword.length;i++){
            listaPassword[i]=new Password(longitud);
            fortalezaPassword[i]=listaPassword[i].esFuerte();
            System.out.println(listaPassword[i].getContraseña()+" "+fortalezaPassword[i]);
        }
    }
 
}

/**
 * Clase Electrodomestico
 *
 * Contiene informacion de los electrodomesticos
 * @author Fernando
 * @version 1.0
 */
public class Electrodomestico {
  
    //Constantes
  
    /**
     * Color por defecto
     */
    protected final static String COLOR_DEF="blanco";
  
    /**
     * Consumo energetico por defecto
     */
    protected final static char CONSUMO_ENERGETICO_DEF='F';
  
    /**
     * Precio base por defecto
     */
    protected final static double PRECIO_BASE_DEF=100;
  
    /**
     * Peso por defecto
     */
    protected final static double PESO_DEF=5;
  
    //Atributos
  
    /**
     * El precio base del electrodomestico
     */
    protected double precioBase;
  
    /**
     * Color del electrodomestico
     */
    protected String color;
  
    /**
     * Indica el consumo energetico del electrodomestico
     */
    protected char consumoEnergetico;
  
    /**
     * Peso del electrodomestico
     */
    protected double peso;
  
    //Métodos privados
  
    private void comprobarColor(String color){
  
        //Colores disponibles
        String colores[]={"blanco", "negro", "rojo", "azul", "gris"};
        boolean encontrado=false;
 
        for(int i=0;i<colores.length && !encontrado;i++){
             
            if(colores[i].equals(color)){
                encontrado=true;
            }
             
        }
         
        if(encontrado){
            this.color=color;
        }else{
            this.color=COLOR_DEF;
        }
         
         
    }
     
    /**
     * Comprueba el consumo energetico
     * Solo mayusculas, si es una 'a' no lo detecta como una 'A'
     * @param consumoEnergetico
     */
    public void comprobarConsumoEnergetico(char consumoEnergetico){
         
        if(consumoEnergetico>=65 && consumoEnergetico<=70){
            this.consumoEnergetico=consumoEnergetico;
        }else{
            this.consumoEnergetico=CONSUMO_ENERGETICO_DEF;
        }
         
    }
  
    //Métodos publicos
    /**
     * Devuelve el precio base del electrodomestico
     * @return precio base del electrodomestico
     */
    public double getPrecioBase() {
        return precioBase;
    }
    /**
     * Devuelve el color del electrodomestico
     * @return color del elesctrodomestico
     */
    public String getColor() {
        return color;
    }
  
     /**
     * Devuelve el consumo energetico del electrodomestico
     * @return consumo energetico del electrodomestico
     */
    public char getConsumoEnergetico() {
        return consumoEnergetico;
    }
    /**
     * Devuelve el peso del electrodomestico
     * @return peso del electrodomestico
     */
    public double getPeso() {
        return peso;
    }
    /**
     * Precio final del electrodomestico
     * @return precio final del electrodomestico
     */
    public double precioFinal(){
        double plus=0;
        switch(consumoEnergetico){
            case 'A':
                plus+=100;
                break;
            case 'B':
                plus+=80;
                break;
            case 'C':
                plus+=60;
                break;
            case 'D':
                plus+=50;
                break;
            case 'E':
                plus+=30;
                break;
            case 'F':
                plus+=10;
                break;
        }
  
        if(peso>=0 && peso<19){
            plus+=10;
        }else if(peso>=20 && peso<49){
            plus+=50;
        }else if(peso>=50 && peso<=79){
            plus+=80;
        }else if(peso>=80){
            plus+=100;
        }
  
        return precioBase+plus;
    }
  
    //Constructores
  
    /**
     * Contructor por defecto
     */
    public Electrodomestico(){
        this(PRECIO_BASE_DEF, PESO_DEF, CONSUMO_ENERGETICO_DEF, COLOR_DEF);
    }
  
    /**
     * Contructor con 2 parametros
     * @param precioBase del electrodomestico
     * @param peso del electrodomestico
     */
    public Electrodomestico(double precioBase, double peso){
        this(precioBase, peso, CONSUMO_ENERGETICO_DEF, COLOR_DEF);
    }
  
    /**
     * Constructor con 4 parametros
     * @param precioBase
     * @param peso
     * @param consumoEnergetico
     * @param color
     */
    public Electrodomestico(double precioBase, double peso, char consumoEnergetico, String color){
        this.precioBase=precioBase;
        this.peso=peso;
        comprobarConsumoEnergetico(consumoEnergetico);
        comprobarColor(color);
    }
  
}

–Clase Lavadora

/**
 * Clase Lavadora
 *
 * Contiene informacion de lavador
 *
 * @author Fernando
 * @version 1.0
 */
public class Lavadora extends Electrodomestico{
 
    //Constantes
 
    /**
     * Carga por defecto
     */
    private final static int CARGA_DEF=5;
 
    //Atributos
 
    /**
     * Carga de la lavadora
     */
    private int carga;
 
    //Métodos publicos
 
    /**
     * Devuelve la carga de la lavadora
     * @return
     */
    public int getCarga() {
        return carga;
    }
 
    /**
     * Precio final de la lavadora
     * @return precio final de la lavadora
     */
    public double precioFinal(){
        //Invocamos el método precioFinal del método padre
        double plus=super.precioFinal();
 
        //añadimos el código necesario
        if (carga>30){
            plus+=50;
        }
 
        return plus;
    }
 
    //Constructor
 
    /**
     * Contructor por defecto
     */
    public Lavadora(){
        this(PRECIO_BASE_DEF, PESO_DEF, CONSUMO_ENERGETICO_DEF, COLOR_DEF, CARGA_DEF);
    }
 
    /**
     * Constructor con 2 parametros
     * @param precioBase
     * @param peso
     */
    public Lavadora(double precioBase, double peso){
        this(precioBase, peso, CONSUMO_ENERGETICO_DEF, COLOR_DEF, CARGA_DEF);
    }
 
    /**
     * Constructor con 5 parametros
     * @param precioBase
     * @param peso
     * @param consumoEnergetico
     * @param color
     * @param carga
     */
    public Lavadora(double precioBase, double peso, char consumoEnergetico, String color, int carga){
        super(precioBase,peso, consumoEnergetico,color);
        this.carga=carga;
    }
}

–Clase Television

/**
 * Clase Television
 *
 * Contiene informacion de una television
 *
 * @author Fernando
 * @version 1.0
 */
public class Television extends Electrodomestico{
 
    //Constantes
 
    /**
     * Resolucion por defecto
     */
    private final static int RESOLUCION_DEF=20;
 
    //Atributos
 
    /**
     * Resolucion del televisor
     */
    private int resolucion;
 
    /**
     * Indica si tiene o no sintonizadorTDT
     */
    private boolean sintonizadorTDT;
 
    //Métodos publicos
 
    /**
     * Precio final de la television
     * @return precio final de la television
     */
    public double precioFinal(){
        //Invocamos el método precioFinal del método padre
        double plus=super.precioFinal();
 
        //Añadimos el codigo necesario
        if (resolucion>40){
            plus+=precioBase*0.3;
        }
        if (sintonizadorTDT){
            plus+=50;
        }
 
        return plus;
    }
 
    //Constructor
 
    /**
     * Constructor por defecto
     */
    public Television(){
        this(PRECIO_BASE_DEF, PESO_DEF, CONSUMO_ENERGETICO_DEF, COLOR_DEF, RESOLUCION_DEF, false);
    }
 
    /**
     * Constructor con 2 parametros
     * @param precioBase
     * @param peso
     */
    public Television(double precioBase, double peso){
        this(precioBase, peso, CONSUMO_ENERGETICO_DEF, COLOR_DEF, RESOLUCION_DEF, false);
    }
 
    /**
     * Contructor con 6 parametros
     * @param precioBase
     * @param peso
     * @param consumoEnergetico
     * @param color
     * @param resolucion
     * @param sintonizadorTDT
     */
    public Television(double precioBase, double peso, char consumoEnergetico, String color, int resolucion, boolean sintonizadorTDT){
        super(precioBase, peso, consumoEnergetico, color);
        this.resolucion=resolucion;
        this.sintonizadorTDT=sintonizadorTDT;
    }
}

–Clase Ejecutable

 /**
 * Clase ejecutable
 * @author DiscoDurodeRoer
 */
public class ElectrodomesticosApp {

    public static void main(String[] args) {
  
        //Creamos un array de Electrodomesticos
        Electrodomestico listaElectrodomesticos[]=new Electrodomestico[10];
  
        //Asignamos cada una de las posiciones como queramos
        listaElectrodomesticos[0]=new Electrodomestico(200, 60, 'C', "Verde");
        listaElectrodomesticos[1]=new Lavadora(150, 30);
        listaElectrodomesticos[2]=new Television(500, 80, 'E', "negro", 42, false);
        listaElectrodomesticos[3]=new Electrodomestico();
        listaElectrodomesticos[4]=new Electrodomestico(600, 20, 'D', "gris");
        listaElectrodomesticos[5]=new Lavadora(300, 40, 'Z', "blanco", 40);
        listaElectrodomesticos[6]=new Television(250, 70);
        listaElectrodomesticos[7]=new Lavadora(400, 100, 'A', "verde", 15);
        listaElectrodomesticos[8]=new Television(200, 60, 'C', "naranja", 30, true);
        listaElectrodomesticos[9]=new Electrodomestico(50, 10);
  
        //Creamos las variables que usaremos para almacenar la suma de los precios
        double sumaElectrodomesticos=0;
        double sumaTelevisiones=0;
        double sumaLavadoras=0;
  
        //Recorremos el array invocando el metodo precioFinal
        for(int i=0;i<listaElectrodomesticos.length;i++){
            /*
             * Cuando una Television o una Lavadora este en la posicion del array actual,
             * pasara por su clase y por la de electrodomestico, ya que una television es un electrodomestico.
             * Ejecutamos en cada uno su propia version del metodo precioFinal
             */
  
            if(listaElectrodomesticos[i] instanceof Electrodomestico){
                sumaElectrodomesticos+=listaElectrodomesticos[i].precioFinal();
            }
            if(listaElectrodomesticos[i] instanceof Lavadora){
                sumaLavadoras+=listaElectrodomesticos[i].precioFinal();
            }
            if(listaElectrodomesticos[i] instanceof Television){
                sumaTelevisiones+=listaElectrodomesticos[i].precioFinal();
            }
        }
  
        //Mostramos los resultados
        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);
        System.out.println("La suma del precio de las televisiones es de "+sumaTelevisiones);
  
    }
  
}

/**
 * Clase Serie
 *
 * Contiene informacion sobre una serie (en general)
 * @author DiscoDurodeRoer
 *
 */
public class Serie implements Entregable{
 
    //Constantes
 
    /**
     * Numero de temporadas por defecto
     */
    private final static int NUM_TEMPORADAS_DEF=3;
 
    /**
     * Constante que indica que un objeto es mayor que otro
     */
    public final static int MAYOR=1;
 
    /**
     * Constante que indica que un objeto es menor que otro
     */
    public final static int MENOR=-1;
 
    /**
     * Constante que indica que un objeto es igual que otro
     */
    public final static int IGUAL=0;
 
    //Atributos
 
    /**
     * Titulo de la serie
     */
    private String titulo;
 
    /**
     * Numero de temporadas de la serie
     */
    private int numeroTemporadas;
 
    /**
     * Indica si esta entregado la serie
     */
    private boolean entregado;
 
    /**
     * Genero de la serie
     */
    private String genero;
 
    /**
     * Creador de la serie
     */
    private String creador;
 
    //Métodos publicos
 
    /**
     * Devuelve el titulo de la serie
     * @return titulo de la serie
     */
    public String getTitulo() {
        return titulo;
    }
 
    /**
     * Modifica el titulo de la serie
     * @param titulo a cambiar
     */
    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }
 
    /**
     * Devuelve la numeroTemporadas de la serie
     * @return numeroTemporadas de la serie
     */
    public int getnumeroTemporadas() {
        return numeroTemporadas;
    }
 
    /**
     * Modifica la numeroTemporadas de la serie
     * @param numeroTemporadas a cambiar
     */
    public void setnumeroTemporadas(int numeroTemporadas) {
        this.numeroTemporadas = numeroTemporadas;
    }
 
    /**
     * Devuelve el genero de la serie
     * @return genero de la serie
     */
    public String getGenero() {
        return genero;
    }
 
    /**
     * Modifica el genero de la serie
     * @param genero a cambiar
     */
    public void setGenero(String genero) {
        this.genero = genero;
    }
 
    /**
     * Devuelve el creador de la serie
     * @return creador de la serie
     */
    public String getcreador() {
        return creador;
    }
 
    /**
     * Modifica el creador de la serie
     * @param creador a cambiar
     */
    public void setcreador(String creador) {
        this.creador = creador;
    }
 
    /**
     * Cambia el estado de entregado a true
     */
    public void entregar() {
        entregado=true;
    }
 
    /**
     * Cambia el estado de entregado a false
     */
    public void devolver() {
        entregado=false;
    }
 
    /**
     * Indica el estado de entregado
     */
    public boolean isEntregado() {
        if(entregado){
            return true;
        }
        return false;
    }
 
    /**
     * Compara dos series segun su numero de temporadas
     * @param objeto a comparar
     * @return codigo numerico
     * <ul>
     * <li>1: La Serie 1 es mayor que la Serie 2</li>
     * <li>0: Las Series son iguales</li>
     * <li>-1: La Serie 1 es menor que la Serie 2</li></ul>
     */
    public int compareTo(Object a) {
        int estado=MENOR;
 
        //Hacemos un casting de objetos para usar el metodo get
        Serie ref=(Serie)a;
        if (numeroTemporadas>ref.getnumeroTemporadas()){
            estado=MAYOR;
        }else if(numeroTemporadas==ref.getnumeroTemporadas()){
            estado=IGUAL;
        }
 
        return estado;
    }
 
    /**
     * Muestra informacion de la Serie
     * @return cadena con toda la informacion de la Serie
     */
    public String toString(){
        return "Informacion de la Serie: \n" +
                "\tTitulo: "+titulo+"\n" +
                "\tNumero de temporadas: "+numeroTemporadas+"\n" +
                "\tGenero: "+genero+"\n" +
                "\tCreador: "+creador;
    }
 
    /**
     * Indica si dos Series son iguales, siendo el titulo y creador iguales
     * @param a Serie a comparar
     * @return true si son iguales y false si son distintos
     */
    public boolean equals(Serie a){
        if (titulo.equalsIgnoreCase(a.getTitulo()) && creador.equalsIgnoreCase(a.getcreador())){
            return true;
        }
        return false;
    }
 
    //Constructor
 
    /**
     * Constructor por defecto
     */
    public Serie(){
        this("",NUM_TEMPORADAS_DEF, "", "");
    }
 
    /**
     * Contructor con 2 parametros
     * @param titulo de la Serie
     * @param creador de la Serie
     */
    public Serie(String titulo, String creador){
        this(titulo,NUM_TEMPORADAS_DEF, "", creador);
    }
 
    /**
     * Constructor con 4 parametros
     * @param titulo de la Serie
     * @param numeroTemporadas de la Serie
     * @param genero de la Serie
     * @param creador de la Serie
     */
    public Serie(String titulo, int numeroTemporadas, String genero, String creador){
        this.titulo=titulo;
        this.numeroTemporadas=numeroTemporadas;
        this.genero=genero;
        this.creador=creador;
        this.entregado=false;
    }
 
}

–Clase Videojuego

/**
 *
 * Clase videojuego
 *
 * Contiene la informacion sobre un videojuego
 *
 * @author DiscoDurodeRoer
 */
public class Videojuego implements Entregable{
 
    //Constantes
 
    /**
     * Horas estimadas por defecto
     */
    private final static int HORAS_ESTIMADAS_DEF=100;
 
    /**
     * Constante que indica que un objeto es mayor que otro
     */
    public final static int MAYOR=1;
 
    /**
     * Constante que indica que un objeto es menor que otro
     */
    public final static int MENOR=-1;
 
    /**
     * Constante que indica que un objeto es igual que otro
     */
    public final static int IGUAL=0;
 
    //Atributos
 
    /**
     * Titulo del videojuego
     */
    private String titulo;
 
    /**
     * Horas estimadas del videojuego
     */
    private int horasEstimadas;
 
    /**
     * Indica si esta o no entregado el videojuego
     */
    private boolean entregado;
 
    /**
     * Genero del videojuego
     */
    private String genero;
 
    /**
     * Compañia del videojuego
     */
    private String compañia;
 
    //Métodos publicos
 
    /**
     * Devuelve el titulo del videojuego
     * @return titulo del videojuego
     */
    public String getTitulo() {
        return titulo;
    }
 
    /**
     * Modifica el titulo del videojuego
     * @param titulo a cambiar
     */
    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }
 
    /**
     * Devuelve el numero de paginas del videojuego
     * @return numero de paginas del videojuego
     */
    public int getHorasEstimadas() {
        return horasEstimadas;
    }
 
    /**
     * Modifica el numero de paginas del videojuego
     * @param horasEstimadas
     */
    public void setHorasEstimadas(int horasEstimadas) {
        this.horasEstimadas = horasEstimadas;
    }
 
    /**
     * Devuelve el genero del videojuego
     * @return genero del videojuego
     */
    public String getGenero() {
        return genero;
    }
 
    /**
     * Modifica el genero del videojuego
     * @param genero a cambiar
     */
    public void setGenero(String genero) {
        this.genero = genero;
    }
 
    /**
     * Devuelve el compañia del videojuego
     * @return compañia del videojuego
     */
    public String getcompañia() {
        return compañia;
    }
 
    /**
     * Modifica el compañia del videojuego
     * @param compañia a cambiar
     */
    public void setcompañia(String compañia) {
        this.compañia = compañia;
    }
 
    /**
     * Cambia el estado de entregado a true
     */
    @Override
    public void entregar() {
        entregado=true;
    }
 
    /**
     * Cambia el estado de entregado a false
     */
    @Override
    public void devolver() {
        entregado=false;
    }
 
    /**
     * Indica el estado de entregado
     * @return 
     */
    @Override
    public boolean isEntregado() {
        if(entregado){
            return true;
        }
        return false;
    }
 
    /**
     * Compara dos videojuegos segun el numero de paginas
     * @return codigo numerico
     * <ul>
     * <li>1: El videojuego 1 es mayor que el videojuego 2</li>
     * <li>0: Los videojuegos son iguales</li>
     * <li>-1: El videojuego 1 es menor que el videojuego 2</li></ul>
     */
    @Override
    public int compareTo(Object a) {
        int estado=MENOR;
 
        //Hacemos un casting de objetos para usar el metodo get
        Videojuego ref=(Videojuego)a;
        if (horasEstimadas>ref.getHorasEstimadas()){
            estado=MAYOR;
        }else if(horasEstimadas==ref.getHorasEstimadas()){
            estado=IGUAL;
        }
 
        return estado;
    }
 
    /**
     * Muestra informacion del videojuego
     * @return cadena con toda la informacion del videojuego
     */
    @Override
    public String toString(){
        return "Informacion del videojuego: \n" +
                "\tTitulo: "+titulo+"\n" +
                "\tHoras estimadas: "+horasEstimadas+"\n" +
                "\tGenero: "+genero+"\n" +
                "\tcompañia: "+compañia;
    }
 
    /**
     * Indica si dos videojuegos son iguales, siendo el titulo y compañia iguales
     * @param a videojuego a comparar
     * @return true si son iguales y false si son distintos
     */
    public boolean equals(Videojuego a){
        if (titulo.equalsIgnoreCase(a.getTitulo()) && compañia.equalsIgnoreCase(a.getcompañia())){
            return true;
        }
        return false;
    }
 
    //Constructor
 
    /**
     * Constructo por defecto
     */
    public Videojuego(){
        this("",HORAS_ESTIMADAS_DEF, "", "");
    }
 
    /**
     * Constructor con 2 parametros
     * @param titulo del videojuego
     * @param compañia del videojuego
     */
    public Videojuego(String titulo, String compañia){
        this(titulo,HORAS_ESTIMADAS_DEF, "", compañia);
    }
 
    /**
     * Constructor con 4 parametros
     * @param titulo del videojuego
     * @param horasEstimadas
     * @param genero del videojuego
     * @param compañia del videojuego
     */
    public Videojuego(String titulo, int horasEstimadas, String genero, String compañia){
        this.titulo=titulo;
        this.horasEstimadas=horasEstimadas;
        this.genero=genero;
        this.compañia=compañia;
        this.entregado=false;
    }

 
}

–Interfaz Entregable

public interface Entregable {
 
    public void entregar();
 
    public void devolver();
 
    public boolean isEntregado();
 
    public int compareTo(Object a);
}

–Clase ejecutable

public class EntregablesApp {
 
    public static void main(String[] args) {
 
        //Creamos dos arrays de cada tipo de objeto
        Serie listaSeries[]=new Serie[5];
        Videojuego listaVideojuegos[]=new Videojuego[5];
 
        //Creamos un objeto en cada posicion del array
        listaSeries[0]=new Serie();
        listaSeries[1]=new Serie("Juego de tronos", "George R. R. Martin ");
        listaSeries[2]=new Serie("Los Simpsons", 25, "Humor", "Matt Groening");
        listaSeries[3]=new Serie("Padre de familia", 12 ,"Humor", "Seth MacFarlane");
        listaSeries[4]=new Serie("Breaking Bad", 5, "Thriller", "Vince Gilligan");
 
        listaVideojuegos[0]=new Videojuego();
        listaVideojuegos[1]=new Videojuego("Assasin creed 2", 30, "Aventura", "EA");
        listaVideojuegos[2]=new Videojuego("God of war 3", "Santa Monica");
        listaVideojuegos[3]=new Videojuego("Super Mario 3DS", 30, "Plataforma", "Nintendo");
        listaVideojuegos[4]=new Videojuego("Final fantasy X", 200, "Rol", "Square Enix");
 
        //entregamos algunos videojuegos y series
        listaSeries[1].entregar();
        listaSeries[4].entregar();
        listaVideojuegos[0].entregar();
        listaVideojuegos[3].entregar();
 
        //Recorremos los arrays para contar cuantos entregados hay, tambien los devolvemos
 
        int entregados=0;
 
        for(int i=0;i<listaSeries.length;i++){
            if(listaSeries[i].isEntregado()){
                entregados+=1;
                listaSeries[i].devolver();
 
            }
            if(listaVideojuegos[i].isEntregado()){
                entregados+=1;
                listaVideojuegos[i].devolver();
            }
        }
 
        System.out.println("Hay "+entregados+" articulos entregados");
 
        //Creamos dos objetos con la primera posicion de cada array
        Serie serieMayor=listaSeries[0];
        Videojuego videojuegoMayor=listaVideojuegos[0];
 
        //Recorremos el array desde la posicion 1 (no 0), comparando el mayor con las posiciones del array
        for(int i=1;i<listaSeries.length;i++){
            if(listaSeries[i].compareTo(serieMayor)==Serie.MAYOR){
                serieMayor=listaSeries[i];
            }
            if(listaVideojuegos[i].compareTo(videojuegoMayor)==Videojuego.MAYOR){
                videojuegoMayor=listaVideojuegos[i];
            }
 
        }
 
        //Mostramos toda la informacion del videojuego y serie mayor
        System.out.println(videojuegoMayor);
        System.out.println(serieMayor);
    }
 
}

–Clase Libro

public class Libro {
    
    /*Atributos*/
    private int ISBN;
    private String titulo;
    private String autor;
    private int numPaginas;
    
    /*Constructores*/
    
    public Libro(int pISBN, String pTitulo, String pAutor, int pNumPaginas){
    
        ISBN=pISBN;
        titulo=pTitulo;
        autor=pAutor;
        numPaginas=pNumPaginas;
    
    }
    
    /*Metodos*/

    public int getISBN() {
        return ISBN;
    }

    public void setISBN(int ISBN) {
        this.ISBN = ISBN;
    }

    public String getTitulo() {
        return titulo;
    }

    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }

    public String getAutor() {
        return autor;
    }

    public void setAutor(String autor) {
        this.autor = autor;
    }

    public int getNumPaginas() {
        return numPaginas;
    }

    public void setNumPaginas(int numPaginas) {
        this.numPaginas = numPaginas;
    }
    
    @Override
    public String toString(){
        return "El libro "+titulo+" con ISBN "+ISBN+""
                + " creado por el autor "+autor
                + " tiene "+numPaginas+" páginas";
    } 
    
    
    
}

–Clase principal

public class Ejercicio_POO_DDR_1 {

    public static void main(String[] args) {
       
        //Creamos lo objetos
        Libro libro1=new Libro(1111111111, "titulo1", "autor1", 30);
        Libro libro2=new Libro(1111111112, "titulo2", "autor2", 60);
        
        //Mostramos su estado
        System.out.println(libro1.toString());
        System.out.println(libro2.toString());
        
        //Modificamos el atributo numPaginas del libro1
        libro1.setNumPaginas(70);
        
        //Comparamos quien tiene mas paginas
        if(libro1.getNumPaginas()>libro2.getNumPaginas()){
            System.out.println(libro1.getTitulo()+" tiene más páginas");
        }else{
            System.out.println(libro2.getTitulo()+" tiene más páginas");
        }
        
        
    }
    
}
}

–Clase Raices

/**
 * Clase Raices
 * Representa una ecuacion de 2º grado
 * @author discoduroderoer
 */
public class Raices {
    
    /*Atributos*/
    private double a;
    private double b;
    private double c;
    
    /**
     * Ecuacion de 2º grado
     * @param a
     * @param b
     * @param c 
     */
    public Raices(double a, double b, double c){
        this.a=a;
        this.b=b;
        this.c=c;
    }
    
    /**
     * Metodos para obtener las raices cuando hay 2 soluciones posibles
     */
    private void obtenerRaices(){
        
        double x1=(-b+Math.sqrt(getDiscriminante()))/(2*a);
        double x2=(-b-Math.sqrt(getDiscriminante()))/(2*a);
        
        System.out.println("Solucion X1");
        System.out.println(x1);
        System.out.println("Solucion X2");
        System.out.println(x2);
    }
    
    /**
     * Obtiene una unica raiz, cuando solo tiene la posibilidad de er una solucion
     */
    private void obtenerRaiz(){
        
        double x=(-b)/(2*a);
        
        System.out.println("Unica solucion");
        System.out.println(x);
        
    }
    
    /**
     * Nos devuelve el valor del discriminante,  
     * @return 
     */
    private double getDiscriminante(){
        return Math.pow(b, 2)-(4*a*c);
    }
    
    /**
     * Si el discriminante es mayor que 0 tiene mas de una raiz
     * (No hemos puesto >= ya que puede confundirse con una solucion)
     * @return 
     */
    private boolean tieneRaices(){
        return getDiscriminante()>0;
    }
    
    /**
     * Si el discriminante es igual a cero tiene una sola raiz
     * @return 
     */
    private boolean tieneRaiz(){
        return getDiscriminante()==0;
    }
    
    /**
     * Nos permite calcular las raices de una ecuacion de 2º grado
     */
    public void calcular(){
        
        if(tieneRaices()){
            obtenerRaices();
        }else if(tieneRaiz()){
            obtenerRaiz();
        }else{
            System.out.println("No tiene soluciones");
        }
        
    }
    
}

–Clase Principal

public class Principal {

    public static void main(String[] args) {
       Raices ecuacion=new Raices(1,4,4); //creamos el objeto
       ecuacion.calcular(); //Calculamos
       
    }
    
}

— Clase Persona

//Clase Persona
public abstract class Persona {
    
    /*Atributos*/
    private String nombre;
    private char sexo;
    private int edad;
    private boolean asistencia;
    
    /*Contantes*/
    private final String[] NOMBRES_CHICOS={"Pepe", "Fernando", "Alberto", "Nacho", "Eustaquio"}; 
    private final String[] NOMBRES_CHICAS={"Alicia", "Laura", "Clotilde", "Pepa", "Elena"}; 
    private final int CHICO=0;
    private final int CHICA=1;
    
    /*Constructores*/
    public Persona(){
        
        //entre 0 y 1
        int determinar_sexo=MetodosSueltos.generaNumeroAleatorio(0,1);
        
        //Si es 0 es un chico
        if(determinar_sexo==CHICO){
            nombre=NOMBRES_CHICOS[MetodosSueltos.generaNumeroAleatorio(0,4)];
            sexo='H';
        }else{
            nombre=NOMBRES_CHICAS[MetodosSueltos.generaNumeroAleatorio(0,4)];
            sexo='M';
        }
        
        //Indicamos la disponibilidad
        disponibilidad();
        
    }

    /*Metodos*/
    
    /**
     * Devuelve el nombre
     * @return 
     */
    public String getNombre() {
        return nombre;
    }

    /**
     * Modifica el nombre
     * @param nombre 
     */
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    /**
     * Devuelve el sexo de la persona
     * @return 
     */
    public char getSexo() {
        return sexo;
    }

    /**
     * Modifica el sexo de la persona
     * @param sexo 
     */
    public void setSexo(char sexo) {
        this.sexo = sexo;
    }

    /**
     * Devuelve la edad de la persona
     * @return 
     */
    public int getEdad() {
        return edad;
    }

    /**
     * Modifica la edad de la edad
     * @param edad 
     */
    public void setEdad(int edad) {
        this.edad = edad;
    }

    /**
     * Indica la asistencia de la persona
     * @return 
     */
    public boolean isAsistencia() {
        return asistencia;
    }

    /**
     * Modifica la asistencia de la persona
     * @param asistencia 
     */
    public void setAsistencia(boolean asistencia) {
        this.asistencia = asistencia;
    }
    
    //abtracto, las clases hijas deben implementarlo
    public abstract void disponibilidad();
    
}

— Clase Alumno

//Clase Alumno, hereda de la clase Persona
public class Alumno extends Persona{
    
    /*Atributos*/
    private int nota;
    
    /*Constructor*/
    public Alumno(){
        super();
        
        nota=MetodosSueltos.generaNumeroAleatorio(0,10);
        
        super.setEdad(MetodosSueltos.generaNumeroAleatorio(12,15));
        
    }

    /*Metodos*/
    
    /**
     * Devuelve la nota
     * @return nota del alumno
     */
    
    public int getNota() {
        return nota;
    }

    /**
     * Modifica la nota del alumno
     * @param nota 
     */
    public void setNota(int nota) {
        this.nota = nota;
    }

    /**
     * Indica si el alumno esta disponible (50%)
     */
    @Override
    public void disponibilidad() {
        
        int prob=MetodosSueltos.generaNumeroAleatorio(0, 100);
        
        if(prob<50){
            super.setAsistencia(false);
        }else{
            super.setAsistencia(true);
        }
        
    }
    
    /**
     * Muestra la informacion del alumno
     * @return informacion
     */
    public String toString(){
        
        return "Nombre: "+super.getNombre()+" ,sexo: "+super.getSexo()+" , nota: "+nota;
       
    }
    
    
    
    
}

— Clase Profesor

//Clase profesor que hereda de la clase Persona
public class Profesor extends Persona{
    
    /*Atributos*/
    private String materia;
   
    /*Constructores*/
    public Profesor(){
       super(); //Llama al constructor padre
       
       super.setEdad(MetodosSueltos.generaNumeroAleatorio(25,50)); //llama al metodo padre
       
       materia=Constantes.MATERIAS[MetodosSueltos.generaNumeroAleatorio(0,2)];
    }

    /*Metodos*/
    
    /**
     * Devuelve la materia del profesor
     * @return 
     */
    public String getMateria() {
        return materia;
    }

    /**
     * Modifica la materia del profesor
     * @param materia 
     */
    public void setMateria(String materia) {
        this.materia = materia;
    }

    /**
     * Calcula la disponibilidad del profesor(20%)
     */
    @Override
    public void disponibilidad() {
       
        int prob=MetodosSueltos.generaNumeroAleatorio(0, 100);
        
        if(prob<20){
            super.setAsistencia(false);
        }else{
            super.setAsistencia(true);
        }
        
    }
   
}

— Clase Aula

public class Aula {
    
    /*Atributos*/
    private int id;
    private Profesor profesor;
    private Alumno[] alumnos;
    private String materia;
    
    /*Constantes*/
    private final int MAX_ALUMNOS=20;
    
    /*Constructores*/
    public Aula(){
        
        id=1;
        
        profesor=new Profesor();
        alumnos= new Alumno[MAX_ALUMNOS];
        creaAlumnos();
        materia=Constantes.MATERIAS[MetodosSueltos.generaNumeroAleatorio(0,2)];
        
    }
    
    /*Metodos*/
    
    /**
     * Crea los alumnos para el aula
     */
    private void creaAlumnos(){
        
        for(int i=0;i<alumnos.length;i++){
            alumnos[i]=new Alumno();
        }
        
    }
    
    
    /**
     * Indica si la asistencia de los alumnos es mayor del 50%
     * @return 
     */
    private boolean asistenciaAlumnos(){
        
        int cuentaAsistencias=0;
        
        //contamos las asistencias
        for(int i=0;i<alumnos.length;i++){
            
            if(alumnos[i].isAsistencia()){
                cuentaAsistencias++;
            }
            
        }
        
        //Muestro la asistencia total
        System.out.println("Hay "+cuentaAsistencias+" alumnos");
        
        return cuentaAsistencias>=((int)(alumnos.length/2));
        
    }
    
    /**
     * Indicamos si se puede dar clase
     * @return 
     */
    public boolean darClase(){
        
        //Indicamos las condiciones para que se pueda dar la clase
        
        if(!profesor.isAsistencia()){
            System.out.println("El profesor no esta, no se puede dar clase");
            return false;
        }else if(!profesor.getMateria().equals(materia)){
            System.out.println("La materia del profesor y del aula no es la misma, no se puede dar clase");
            return false;
        }else if (!asistenciaAlumnos()){
            System.out.println("La asistencia no es suficiente, no se puede dar clase");
            return false;
        }
        
        System.out.println("Se puede dar clase");
        return true;
        
    }
    
    /**
     * Indicamos las notas de los alumnos aprobados, chicos y chicas
     */
    public void notas(){
        
        int chicosApro=0;
        int chicasApro=0;
        
         for(int i=0;i<alumnos.length;i++){
           
           //Comprobamos si el alumno esta aprobado
           if(alumnos[i].getNota()>=5){
               //Segun el sexo, aumentara uno o otro
               if(alumnos[i].getSexo()=='H'){
                   chicosApro++;
               }else{
                   chicasApro++;
               }
               
               System.out.println(alumnos[i].toString());
               
           }
            
        }
         
        System.out.println("Hay "+chicosApro+" chicos y "+chicasApro+" chicas aprobados/as");
        
    }
    
}

— Clase Constantes

//Clase constantes
public class Constantes {
    
    public static final String[] MATERIAS={"Matematicas", "Filosofia", "Fisica"};
    
}

— Clase MetodosSueltos

public class MetodosSueltos {
    
    /**
     * Genera un numero aleatorio entre dos numeros.
     * Entre el minimo y el maximo
     * @param minimo
     * @param maximo
     * @return numero entre minimo y maximo
     */
    public static int generaNumeroAleatorio(int minimo, int maximo){
        
        int num=(int)Math.floor(Math.random()*(minimo-(maximo+1))+(maximo+1));
        return num;
    }
    
}

— Clase Principal

public class Principal {

    public static void main(String[] args) {
       
        //Creamos el objeto
        Aula aula=new Aula();
        
        //Indicamos si se puede dar la clase
        if(aula.darClase()){
            aula.notas();
        }
        
    }
    
}

— Clase Espectador

/**
 * Clase Espectador, lleva todo lo relativo a la información del espectador
 *
 * @author DiscoDurodeRoer
 */
public class Espectador {

    /*Atributos*/
    private String nombre;
    private int edad;
    private double dinero;

    /*Constructores*/
    public Espectador(String nombre, int edad, double dinero) {
        this.nombre = nombre;
        this.edad = edad;
        this.dinero = dinero;
    }

    /*Metodos*/
    public String getNombre() {
        return nombre;
    }

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

    public int getEdad() {
        return edad;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }

    public double getDinero() {
        return dinero;
    }

    public void setDinero(double dinero) {
        this.dinero = dinero;
    }

    /**
     * Pagamos la entrada del cine
     *
     * @param precio
     */
    public void pagar(double precio) {
        dinero -= precio;
    }

    /**
     * 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
     * espectador)
     *
     * @param edadMinima
     * @return
     */
    public boolean tieneEdad(int edadMinima) {
        return edad >= edadMinima;
    }

    /**
     * Indicamos si el espectador tiene dinero (en el video estaba en la clase
     * cine tiene mas sentido que sea un metodo del espectador)
     *
     * @param precioEntrada
     * @return
     */
    public boolean tieneDinero(double precioEntrada) {
        return dinero >= precioEntrada;
    }

    @Override
    public String toString() {
        return "el nombre del espectador es " + nombre + " de " + edad + " años y con " + dinero + " euros en su bolsillo";
    }

}

— Clase Asiento

/**
 * Clase asiento, se usa para manejar toda la informacion relativa al asiento
 *
 * @author DiscoDurodeRoer
 */
public class Asiento {

    /*Atributos*/
    private char letra;
    private int fila;
    private Espectador espectador; // informacion del espectador que esta sentado, null si es vacio

    /*Constructores*/
    public Asiento(char letra, int fila) {
        this.letra = letra;
        this.fila = fila;
        this.espectador = null; //al iniciar el asiento, no habrá nadie sentado
    }

    /*Metodos*/
    public char getLetra() {
        return letra;
    }

    public void setLetra(char letra) {
        this.letra = letra;
    }

    public int getFila() {
        return fila;
    }

    public void setFila(int fila) {
        this.fila = fila;
    }

    public Espectador getEspectador() {
        return espectador;
    }

    public void setEspectador(Espectador espectador) {
        this.espectador = espectador;
    }

    /**
     * Indica si el asiento esta ocupado
     *
     * @return
     */
    public boolean ocupado() {
        return espectador != null;
    }

    @Override
    public String toString() {
        if (ocupado()) {
            return "Asiento: " + fila + letra + " y " + espectador;
        }

        return "Asiento: " + fila + letra + " y este asiento está vacio ";

    }

}

— Clase Pelicula

/**
 * Clase Pelicula, lleva todo lo relacionado con la pelicula
 *
 * @author DiscoDurodeRoer
 */
public class Pelicula {

    /*Atributos*/
    private String titulo;
    private int duracion;
    private int edadMinima;
    private String director;

    /*Constructor*/
    public Pelicula(String titulo, int duracion, int edadMinima, String director) {
        this.titulo = titulo;
        this.duracion = duracion;
        this.edadMinima = edadMinima;
        this.director = director;
    }

    /*Metodos*/
    public String getTitulo() {
        return titulo;
    }

    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }

    public int getDuracion() {
        return duracion;
    }

    public void setDuracion(int duracion) {
        this.duracion = duracion;
    }

    public int getEdadMinima() {
        return edadMinima;
    }

    public void setEdadMinima(int edadMinima) {
        this.edadMinima = edadMinima;
    }

    public String getDirector() {
        return director;
    }

    public void setDirector(String director) {
        this.director = director;
    }

    @Override
    public String toString() {
        return "'" + titulo + "' del director " + director + ", con una duracion de " + duracion + " minutos y la edad minima es de " + edadMinima + " años";
    }

}

— Clase Cine

/**
 * Clase Cine, lleva todo lo relativo al cine
 *
 * @author DiscoDurodeRoer
 */
public class Cine {

    /*Atributos*/
    private Asiento asientos[][];
    private double precio;
    private Pelicula pelicula;

    /*Constructor*/
    public Cine(int filas, int columnas, double precio, Pelicula pelicula) {

        asientos = new Asiento[filas][columnas];
        this.precio = precio;
        this.pelicula = pelicula;
        rellenaButacas();
    }

    /*Metodos*/
    public Asiento[][] getAsientos() {
        return asientos;
    }

    public void setAsientos(Asiento[][] asientos) {
        this.asientos = asientos;
    }

    public double getPrecio() {
        return precio;
    }

    public void setPrecio(double precio) {
        this.precio = precio;
    }

    public Pelicula getPelicula() {
        return pelicula;
    }

    public void setPelicula(Pelicula pelicula) {
        this.pelicula = pelicula;
    }

    /**
     * Rellena nuestros asientos, dandoles una fila y una letra
     */
    private void rellenaButacas() {

        int fila = asientos.length;
        for (int i = 0; i < asientos.length; i++) {
            for (int j = 0; j < asientos[0].length; j++) {
                //Recuerda que los char se pueden sumar
                asientos[i][j] = new Asiento((char) ('A' + j), fila);
            }
            fila--; //Decremento la fila para actualizar la fila
        }

    }

    /**
     * Indicamos si hay sitio en el cine, cuando vemos una vacia salimos de la
     * función
     *
     * @return
     */
    public boolean haySitio() {

        for (int i = 0; i < asientos.length; i++) {
            for (int j = 0; j < asientos[0].length; j++) {

                if (!asientos[i][j].ocupado()) {
                    return true;
                }

            }
        }

        return false;
    }

    /**
     * Indico si en una posicion concreta esta ocupada
     *
     * @param fila
     * @param letra
     * @return
     */
    public boolean haySitioButaca(int fila, char letra) {
        return getAsiento(fila, letra).ocupado();
    }

    /**
     * Indicamos si el espectador cumple lo necesario para entrar: - Tiene
     * dinero - Tiene edad El tema de si hay sitio, se controla en el main
     *
     * @param e
     * @return
     */
    public boolean sePuedeSentar(Espectador e) {
        return e.tieneDinero(precio) && e.tieneEdad(pelicula.getEdadMinima());
    }

    /**
     * Siento al espectador en un asiento
     *
     * @param fila
     * @param letra
     * @param e
     */
    public void sentar(int fila, char letra, Espectador e) {
        getAsiento(fila, letra).setEspectador(e);
    }

    /**
     * Devuelvo un asiento concreto por su fila y letra
     *
     * @param fila
     * @param letra
     * @return
     */
    public Asiento getAsiento(int fila, char letra) {
        return asientos[asientos.length - fila - 1][letra - 'A'];
    }

    /**
     * Numero de filas de nuestro cine
     *
     * @return
     */
    public int getFilas() {
        return asientos.length;
    }

    /**
     * Numero de columas de nuestro cine
     *
     * @return
     */
    public int getColumnas() {
        return asientos[0].length;
    }

    /**
     * Mostramos la información de nuestro cine (Tambien se puede hacer en un
     * toString pero hay que devolver un String)
     */
    public void mostrar() {

        System.out.println("Información cine");
        System.out.println("Pelicula reproducida: " + pelicula);
        System.out.println("Precio entrada: " + precio);
        System.out.println("");
        for (int i = 0; i < asientos.length; i++) {
            for (int j = 0; j < asientos[0].length; j++) {
                System.out.println(asientos[i][j]);
            }
            System.out.println("");
        }
    }

}

— Clase Metodos

/**
 * Clase Metodos, contiene funciones útiles para nuestro programa
 *
 * @author DiscoDuroDeroer
 */
public class Metodos {

    public static final String nombres[] = {"Fernando", "Laura", "Pepe", "Eufrasio"};

    public static int generaNumeroEnteroAleatorio(int minimo, int maximo) {
        int num = (int) (Math.random() * (minimo - (maximo + 1)) + (maximo + 1));
        return num;
    }

}

— Clase Principal

import java.util.Scanner;

/**
 * Clase ejecutable
 * @author DiscoDurodeRoer
 */
public class Principal {

    public static void main(String[] args) {

        //Creo la pelicula
        Pelicula pelicula = new Pelicula("Mi vida", 90, 16, "DDR");
        
        // Pido datos (esto no se mostro en el video por falta de tiempo)
        // No valida nada al respecto de tamaños (siguiente version)
        Scanner sn = new Scanner(System.in);
        
        System.out.println("Introduce el numero de filas");
        int filas=sn.nextInt();
        
        System.out.println("Introduce el numero de columnas");
        int columnas=sn.nextInt();
        
        System.out.println("Introduce el precio de la entrada de cine");
        double precio=sn.nextDouble();
        
        //Creo el cine, necesito la pelicula para ello
        Cine cine = new Cine(filas, columnas, precio, pelicula);

        //Numero de espectadores que seran creados
        System.out.println("Introduce el numero de espectadores a crear");
        int numEspectadores = sn.nextInt();

        //Variables y objetos usados
        Espectador e;
        int fila;
        char letra;

        System.out.println("Espectadores generados: ");
        //Termino cuando no queden espectadores o no haya mas sitio en el cine
        for (int i = 0; i < numEspectadores &amp;&amp; cine.haySitio(); i++) {

            //Generamos un espectador
            e = new Espectador(
                    Metodos.nombres[Metodos.generaNumeroEnteroAleatorio(0, Metodos.nombres.length - 1)], //Nombre al azar
                    Metodos.generaNumeroEnteroAleatorio(10, 30), //Generamos una edad entre 10 y 30
                    Metodos.generaNumeroEnteroAleatorio(1, 10)); //Generamos el dinero entre 1 y 10 euros

            //Mostramos la informacion del espectador
            System.out.println(e);
            
            //Generamos una fila y letra
            //Si esta libre continua sino busca de nuevo
            do {

                fila = Metodos.generaNumeroEnteroAleatorio(0, cine.getFilas() - 1);
                letra = (char) Metodos.generaNumeroEnteroAleatorio('A', 'A' + (cine.getColumnas()-1));

            } while (cine.haySitioButaca(fila, letra));

            //Si el espectador cumple con las condiciones
            if (cine.sePuedeSentar(e)) {
                e.pagar(cine.getPrecio()); //El espectador paga el precio de la entrada
                cine.sentar(fila, letra, e); //El espectador se sienta
            }

        }

        System.out.println("");
        cine.mostrar(); //Mostramos la información del cine, tambien se puede usar un toString
        
        System.out.println("Fin");

    }

}

— Carta

/**
 * Clase Carta
 * @author Disco Duro de Roer
 */
public class Carta {
    
    //Atributos
    private int numero;
    private String palo;
    
    //Constantes
    public static final String[] PALOS={"ESPADAS", "OROS", "COPAS", "BASTOS"};
    public static final int LIMITE_CARTA_PALO=12;

    //Constructor
    public Carta(int numero, String palo) {
        this.numero = numero;
        this.palo = palo;
    }

    @Override
    public String toString() {
        return "numero=" + numero + ", palo=" + palo;
    }
    
}

— Baraja

/**
 * Clase Baraja
 * @author Disco Duro de Roer
 */
public class Baraja {

    //Atributos
    private Carta cartas[];
    private int posSiguienteCarta;

    //Cartas
    public static final int NUM_CARTAS = 40;

    public Baraja() {
        this.cartas = new Carta[NUM_CARTAS];
        this.posSiguienteCarta = 0;
        crearBaraja(); //Creamos la baraja
        barajar(); // barajamos la baraja
    }

    /**
     * Crea la baraja ordenada
     */
    private void crearBaraja() {

        String[] palos = Carta.PALOS;

        //Recorro los palos
        for (int i = 0; i < palos.length; i++) {

            //Recorro los numeros
            for (int j = 0; j < Carta.LIMITE_CARTA_PALO; j++) {
                //Las posiciones del 8 y del 9 son el 7 y el 8 (emepzamos en 8)
                if (!(j == 7 || j == 8)) {
                    if (j >= 9) {
                        //Solo para la sota, caballo y rey
                        cartas[((i * (Carta.LIMITE_CARTA_PALO - 2)) + (j - 2))] = new Carta(j + 1, palos[i]);
                    } else {
                        //Para los casos de 1 a 7
                        cartas[((i * (Carta.LIMITE_CARTA_PALO - 2)) + j)] = new Carta(j + 1, palos[i]);
                    }

                }
            }

        }

    }

    /**
     * Baraja todas las cartas
     */
    public void barajar() {

        int posAleatoria = 0;
        Carta c;

        //Recorro las cartas
        for (int i = 0; i < cartas.length; i++) {

            posAleatoria = Metodos.generaNumeroEnteroAleatorio(0, NUM_CARTAS - 1);

            //intercambio
            c = cartas[i];
            cartas[i] = cartas[posAleatoria];
            cartas[posAleatoria] = c;

        }

        //La posición vuelve al inicio
        this.posSiguienteCarta = 0;

    }

    /**
     * Devuelve la casta donde se encuentre "posSiguienteCarta"
     * @return carta del arreglo
     */
    public Carta siguienteCarta() {

        Carta c = null;

        if (posSiguienteCarta == NUM_CARTAS) {
            System.out.println("Ya no hay mas cartas, barajea de nuevo");
        } else {
            c = cartas[posSiguienteCarta++];
        }

        return c;

    }

    /**
     * Devuelve un numero de cartas. Controla si hay mas cartas de las que se piden 
     * @param numCartas
     * @return 
     */
    public Carta[] darCartas(int numCartas) {

        if (numCartas > NUM_CARTAS) {
            System.out.println("No se puede dar mas cartas de las que hay");
        } else if (cartasDisponible() < numCartas) {
            System.out.println("No hay suficientes cartas que mostrar");
        } else {

            Carta[] cartasDar = new Carta[numCartas];

            //recorro el array que acabo de crear para rellenarlo
            for (int i = 0; i < cartasDar.length; i++) {
                cartasDar[i] = siguienteCarta(); //uso el metodo anterior
            }
            
            //Lo devuelvo
            return cartasDar;

        }

        //solo en caso de error
        return null;

    }

    /**
     * Indica el numero de cartas que hay disponibles
     * @return 
     */
    public int cartasDisponible() {
        return NUM_CARTAS - posSiguienteCarta;
    }

    /**
     * Muestro las cartas que ya han salido
     */
    public void cartasMonton() {

        if (cartasDisponible() == NUM_CARTAS) {
            System.out.println("No se ha sacado ninguna carta");
        } else {
            //Recorro desde 0 a la posSiguienteCarta
            for (int i = 0; i < posSiguienteCarta; i++) {
                System.out.println(cartas[i]);
            }
        }

    }

    /**
     * Muestro las cartas que aun no han salido
     */
    public void mostrarBaraja() {

        if (cartasDisponible() == 0) {
            System.out.println("No hay cartas que mostrar");
        } else {
            for (int i = posSiguienteCarta; i < cartas.length; i++) {
                System.out.println(cartas[i]);
            }
        }

    }

}

— Métodos

/**
 * Clase Metodos, contiene métodos estaricos sueltos
 * @author Trabajo
 */
public class Metodos {

    public static int generaNumeroEnteroAleatorio(int minimo, int maximo) {
        int num = (int) (Math.random() * (minimo - (maximo + 1)) + (maximo + 1));
        return num;
    }

}

— Main

public class Ejercicio_POO_DDR_05 {

    public static void main(String[] args) {
        
        //Creamos la baraja
        Baraja b = new Baraja();
        
        //Mostramos las cartas disponibles (40)
        System.out.println("Hay "+b.cartasDisponible()+" cartas disponibles");
       
        //Saco una carta
        b.siguienteCarta();
        
        //Saco 5 cartas
        b.darCartas(5);
        
        //Mostramos las cartas disponibles (34)
        System.out.println("Hay "+b.cartasDisponible()+" cartas disponibles");
       
        System.out.println("Cartas sacadas de momento");
        
        b.cartasMonton();
        
        
        //Barajamos de nuevo
        b.barajar();
       
        //Saco 5 cartas
        Carta[] c = b.darCartas(5);
        
        System.out.println("Cartas sacadas despues de barajar ");
        for(int i=0;i<c.length;i++){
            System.out.println(c[i]);
        }
        
    }
    
}

— Constantes

/**
 * Interfaz Constantes
 * @author Disco Duro de Roer
 */
public interface Constantes {
    public final int NUMERO_PARTIDOS=2;
    
    public final int NUMERO_JORNADAS=38;
    public final double DINERO_INICIAL=35;
    
    public final int RESULTADO_MINIMO=0;
    public final int RESULTADO_MAXIMO=3;
    
    public final double DINERO_CADA_JORNADA=1;
    
    public final Jugador[] JUGADORES={ 
                                    new Jugador("Make"),
                                    new Jugador("JuanMa"),
                                    new Jugador("Fernando"),
                                    new Jugador("Alberto"),
                                    new Jugador("Lorente"),
                                    new Jugador("Adrian"),
                                    new Jugador("Maria"),
                                    new Jugador("Parra"),
                                    new Jugador("Pablo"),
                                    new Jugador("Prieto"),
                                    new Jugador("Ruben"),
                                    new Jugador("Jony"),
                                    new Jugador("Fran"),
                                    new Jugador("Isidoro"),
                                    new Jugador("Rafa")
                                };
}

— Jugador

/**
 * Clase Jugador
 * @author Disco Duro de Roer
 */
public class Jugador implements Constantes, MetodosInterfaz{
 
    private String nombre;
    private double dinero;
    private int porrasGanadas;
    private String[] resultados;
    
    public Jugador(String nombre){
        this.nombre=nombre;
        this.dinero = DINERO_INICIAL;
        this.porrasGanadas=0;
        this.resultados = new String[NUMERO_PARTIDOS];
        reiniciarResultados();
    }
    
    public void reiniciarResultados(){
        
        for(int i=0;i<resultados.length;i++){
            resultados[i]="";
        }
        
    }
    
    public boolean puedePagar(){
        return dinero>=DINERO_CADA_JORNADA;
    }
    
    public void ponerEnElBote(){
        dinero-=DINERO_CADA_JORNADA;
        System.out.println("Jugador "+nombre+" ha puesto "+DINERO_CADA_JORNADA+" euro/s y le queda "+dinero+" euro/s");
    }
    
    public void ganarBote(double bote){
        dinero+=bote;
        porrasGanadas++;
        System.out.println("Jugador "+nombre+" ha ganado "+bote+" euro/s y tiene "+dinero+" euro/s");
    }
    
    @Override
    public void generarResultados() {
        
        int pLocal, pVisitante;
        
        for(int i=0;i<resultados.length;i++){
            pLocal = Metodos.generaNumeroAleatorio(RESULTADO_MINIMO, RESULTADO_MAXIMO);
            pVisitante = Metodos.generaNumeroAleatorio(RESULTADO_MINIMO, RESULTADO_MAXIMO);
            
            resultados[i] = pLocal +" - "+pVisitante;
            
            System.out.println("El Jugador "+nombre+" ha elegido el resultado "+resultados[i]);
            
        }
        System.out.println("");
    }
    
    public boolean haAcertadoPorra(String[] resultados_partidos){
        
        for(int i=0;i<resultados.length;i++){
            if(!resultados[i].equals(resultados_partidos[i])){
                return false;
            }    
        }
        return true;
        
    }
    

    @Override
    public String toString() {
        return "El jugador " + nombre + " tiene dinero=" + dinero + " y ha ganado " + porrasGanadas + " porra/s";
    }
    
}

— Métodos

/**
 * Clase Métodos
 * @author Disco Duro de Roer
 */
public class Metodos {
    
    /**
     * Genera un numero aleatorio entre un minimo y un maximo
     * @param minimo
     * @param maximo
     * @return 
     */
     public static int generaNumeroAleatorio(int minimo, int maximo){
        int num=(int)Math.floor(Math.random()*(minimo-(maximo+1))+(maximo+1));
        return num;
    }
}

— Métodos Interfaz

public interface MetodosInterfaz {
    
    public void generarResultados();
    
}

— POOrra

/**
 * Clase POOrra
 * @author Disco Duro de Roer
 */
public class POOrra implements Constantes{
    
    private double bote;
    
    public POOrra(){
        bote=0;
    }
    
    /**
     * Aumenta la cantidad del bote
     * @param dinero 
     */
    public void aumentarBote(double dinero){
        bote+=dinero;
    }
    
    /**
     * Dejamos el bote a 0
     */
    public void vacirBote(){
        bote=0;
    }
    
    /**
     * Metodo principal que simula el transcurso de la porra
     */
    public void jornadas(){
        
        Resultados resultados = new Resultados();
        String[] partidos;
        
        //Recorremos las jornadas
        for(int i=0;i<NUMERO_JORNADAS;i++){
            
            System.out.println("JORNADA "+(i+1));
            System.out.println("");
            
            //Apuesta
            for(int j=0;j<JUGADORES.length;j++){
                //Si un jugador puede pagar
                if(JUGADORES[j].puedePagar()){
                    //el jugador paga, dice sus resultados y el bote se aumenta
                    JUGADORES[j].ponerEnElBote();
                    JUGADORES[j].generarResultados();
                    aumentarBote(DINERO_CADA_JORNADA);
                }else{
                    //Si no puede pagar, los resultados se vacian
                    JUGADORES[j].reiniciarResultados();
                }
                
            }
            
            
            //Partido
            resultados.generarResultados();
            partidos = resultados.getPartidos();
            
            //Comprobacion
            for(int j=0;j<JUGADORES.length;j++){
                //Indica si ha acertado
                if (JUGADORES[j].haAcertadoPorra(partidos)){
                    //Le damos el bota al jugador y vaciamos el bote
                    JUGADORES[j].ganarBote(bote);
                    vacirBote();
                }
                
            }
            
            System.out.println("");
            System.out.println("");
            
            System.out.println(toString());
            
            System.out.println("");
            System.out.println("");
            
        }
        
        //Motramos el estado de los jugadores
        for(int i=0;i<JUGADORES.length;i++){
            System.out.println(JUGADORES[i]);
        }
        
    }

    @Override
    public String toString() {
        return "En la POOrra hay de bote" + bote + " euro/s";
    }
    
}

— Resultados

/**
 * Clase Resultados
 * @author Disco Duro de Roer
 */
public class Resultados implements Constantes,MetodosInterfaz{
    
    private String[] partidos;

    public Resultados() {
        partidos=new String[NUMERO_PARTIDOS];
    }

    /**
     * Genera los resultado del partido
     */
    @Override
    public void generarResultados() {
        
        int pLocal, pVisitante;
        
        for(int i=0;i<partidos.length;i++){
            //Generamos los resultados
            pLocal = Metodos.generaNumeroAleatorio(RESULTADO_MINIMO, RESULTADO_MAXIMO);
            pVisitante = Metodos.generaNumeroAleatorio(RESULTADO_MINIMO, RESULTADO_MAXIMO);
            
            partidos[i] = pLocal +" - "+pVisitante;
            
            System.out.println("El partido "+(i+1)+" ha generado el resultado "+partidos[i]);
        }
        
    }

    public String[] getPartidos() {
        return partidos;
    }

}

— Main

public class Ejercicio_POO_DDR_06 {

    public static void main(String[] args) {
        POOrra p = new POOrra();
        p.jornadas();
        
    }
    
}

— Revolver

public class Revolver {

    //Atributos
    private int posicionBalaActual;
    private int posicionBala;

    //Constructor
    public Revolver() {
        posicionBalaActual = Metodos.generaNumeroAleatorio(1, 6);
        posicionBala = Metodos.generaNumeroAleatorio(1, 6);
    }

    //Metodos
    
    //Dispara el revolver
    public boolean disparar() {

        boolean exito = false;

        if (posicionBalaActual == posicionBala) {
            exito = true; //Alguien va a morir...
        }

        siguienteBala();

        return exito;

    }

    //Cambia a la siguiente posicion
    public void siguienteBala() {

        if (posicionBalaActual == 6) {
            posicionBalaActual = 1; //posicion incial
        } else {
            posicionBalaActual++;
        }

    }

    public String toString() {
        return "Posicion Bala Actual: " + posicionBalaActual + ", Posicion bala: " + posicionBala;
    }

}

— Jugador

/**
 * @author Discoduroderoer
 */
public class Jugador {

    //Atributos
    private int id;
    private String nombre;
    private boolean vivo;

    //Contructor
    public Jugador(int id) {
        this.id = id;
        this.nombre = "Jugador " + id;
        this.vivo = true;
    }

    //Propiedades
    
    /**
     * El jugador dispara el revolver
     * @param r 
     */
    public void disparar(Revolver r) {

        System.out.println("El " + nombre + " se apunta con la pistola");

        //El jugador se pone el revolver y...
        if (r.disparar()) {
            this.vivo = false; //muere
            System.out.println("El " + nombre + " ha muerto...");
        } else {
            System.out.println("El " + nombre + " se ha librado..."); //No muere
        }

    }

    public boolean isVivo() {
        return vivo;
    }

}

— Metodos

/**
 * @author Discoduroderoer
 */
public class Metodos {

    /**
     * Genera un numero aleatorio entre dos numeros
     * @param minimo
     * @param maximo
     * @return 
     */
    public static int generaNumeroAleatorio(int minimo, int maximo) {
        int num = (int) Math.floor(Math.random() * (maximo - minimo + 1) + (minimo));
        return num;
    }

}

— Juego

/**
 * @author Discoduroderoer
 */
public class Juego {

    //atributos
    private Jugador[] jugadores;
    private Revolver revolver;

    //Constructor
    public Juego(int numJugadores) {

        jugadores = new Jugador[comprobarJugadores(numJugadores)];

        crearJugadores();

        revolver = new Revolver();

    }

    //Comprueba que el numero de jugadores esta en el rango correcto
    private int comprobarJugadores(int numJugadores) {

        //Sino esta en el rango correcto se pone a 6
        if (!(numJugadores >= 1 && numJugadores <= 6)) {
            numJugadores = 6;
        }

        return numJugadores;
    }

    //Crea los jugadores
    private void crearJugadores() {
        for (int i = 0; i < jugadores.length; i++) {
            jugadores[i] = new Jugador(i + 1);
        }
    }

    //indica si el juego acaba o no
    public boolean finJuego() {

        for (int i = 0; i < jugadores.length; i++) {
            if (!jugadores[i].isVivo()) {
                //Acabo el juego
                return true;
            }
        }
        return false; //No termina el juego
    }

    //Realiza una ronda (si muere algun jugador todos participan igualmente)
    public void ronda() {

        for (int i = 0; i < jugadores.length; i++) {
            //El jugador se dispara
            jugadores[i].disparar(revolver);
        }

    }
    
    //Realiza una ronda (si muere algun jugador, los siguientes no participan)
    public void rondaV2() {

        for (int i = 0; i < jugadores.length; i++) {
            jugadores[i].disparar(revolver);
            
            //Si muere, terminamos
            if(!jugadores[i].isVivo()){
                return;
            }
        }

    }

}

— Main

/**
 * @author Discoduroderoer
 */
public class Ejercicio_POO_DDR_07 {

    public static void main(String[] args) {
        
        Juego juego = new Juego(2);
        
        while( !juego.finJuego() ){
            juego.ronda();            
            //juego.rondaV2();
        }
        
        System.out.println("El juego ha terminado");
        
    }
    
}

— Empleado

/**
 * Clase Empleado, es abtracta
 *
 * @author DiscoDurodeRoer
 */
public abstract class Empleado {

    //Atributos
    private String nombre;
    private int edad;
    private double salario;

    //Constantes
    public final double PLUS = 300;

    //Constructores
    public Empleado(String nombre, int edad, double salario) {
        this.nombre = nombre;
        this.edad = edad;
        this.salario = salario;
    }

    //Metodos
    public String getNombre() {
        return nombre;
    }

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

    public int getEdad() {
        return edad;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }

    public double getSalario() {
        return salario;
    }

    public void setSalario(double salario) {
        this.salario = salario;
    }

    @Override
    public String toString() {
        return "nombre=" + nombre + ", edad=" + edad + ", salario=" + salario + ", ";
    }

    //Metodo abstracto, obliga a las clases hijas que implementen esta función
    public abstract boolean plus();

}

— Comercial

/**
 * Clase comercial, hija de Empleado
 *
 * @author DiscoDurodeRoer
 */
public class Comercial extends Empleado {

    //Atributos
    private double comision;

    //Constructores
    public Comercial(double comision, String nombre, int edad, double salario) {
        super(nombre, edad, salario);
        this.comision = comision;
    }

    //Metodos
    public double getComision() {
        return comision;
    }

    public void setComision(double comision) {
        this.comision = comision;
    }

    /**
     * Devuelve el estado del objeto, llama primero al toString de la clase
     * padre
     *
     * @return
     */
    @Override
    public String toString() {
        return super.toString() + " comision=" + comision;
    }

    /**
     * Si tiene mas de 30 años y la comision es mayor que 200, aumentamos el
     * sueldo al empleado
     *
     * @return
     */
    @Override
    public boolean plus() {

        if (super.getEdad() > 30 && this.comision > 200) {
            //Con super. llamo a un metodo de la clase padre
            double nuevoSalario = super.getSalario() + super.PLUS;
            super.setSalario(nuevoSalario);
            System.out.println("Se le añadido el plus, al empleado " + super.getNombre());
            return true;
        }

        return false;

    }

}

— Repartidor

/**
 * Clase Repartidor, hija de empleado
 * @author DiscoDurodeRoer
 */
public class Repartidor extends Empleado {

    //Atributos
    private String zona;

    //Constructores
    public Repartidor(String zona, String nombre, int edad, double salario) {
        super(nombre, edad, salario);
        this.zona = zona;
    }

    //Metodos
    public String getZona() {
        return zona;
    }

    public void setZona(String zona) {
        this.zona = zona;
    }

    @Override
    public String toString() {
        return super.toString() + " zona=" + zona;
    }

    /**
     * Si tiene menos de 25 años y la zona es "zona 3",
     * aumentamos el sueldo al empleado
     * @return 
     */
    @Override
    public boolean plus() {

        if (super.getEdad() < 25 && this.zona.equalsIgnoreCase("zona 3")) {
            //Con super. llamo a un metodo de la clase padre
            double nuevoSalario = super.getSalario() + super.PLUS;
            super.setSalario(nuevoSalario);
            System.out.println("Se le añadido el plus, al empleado "+super.getNombre());
            return true;
        }

        return false;
    }

}

— Main

public class Ejercicio_POO_DDR_08 {

    public static void main(String[] args) {

        //Creamos los objetos
        Comercial c1 = new Comercial(300, "DDR", 37, 1000);
        Repartidor r1 = new Repartidor("zona 3", "Fer", 26, 900);

        //Llamamos a plus
        c1.plus();
        r1.plus();

        //Mostramos la informacion
        System.out.println(c1);
        System.out.println(r1);
    }

}

— Producto

/**
 * Clase Producto, clase padre
 * @author DiscoDurodeRoer
 */
public class Producto {
    
    //Atributos
    private String nombre;
    private double precio;

    //Constructores
    public Producto(String nombre, double precio) {
        this.nombre = nombre;
        this.precio = precio;
    }

    //Metodos
    public String getNombre() {
        return nombre;
    }

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

    public double getPrecio() {
        return precio;
    }

    public void setPrecio(double precio) {
        this.precio = precio;
    }

    @Override
    public String toString() {
        return "nombre=" + nombre + ", precio=" + precio +", ";
    }
    
    /**
     * Indica el precio total segun una cantidad
     * @param cantidad
     * @return 
     */
    public double calcular(int cantidad){
        return precio*cantidad;
    }
    
    
}

— Perecedero

/**
 * Clase Perecedero, clase hija de Producto
 * @author DiscoDurodeRoer
 */
public class Perecedero extends Producto {

    //Atributos
    private int dias_a_caducar;

    //Constructores
    public Perecedero(int dias_a_caducar, String nombre, double precio) {
        super(nombre, precio);
        this.dias_a_caducar = dias_a_caducar;
    }

    //Metodos
    public int getDias_a_caducar() {
        return dias_a_caducar;
    }

    public void setDias_a_caducar(int dias_a_caducar) {
        this.dias_a_caducar = dias_a_caducar;
    }

    @Override
    public String toString() {
        return super.toString() + " dias_a_caducar=" + dias_a_caducar;
    }

    /**
     * Calcula el precio segun una cantidad,
     * tambien segun los dias que le queden al prodcuto,
     * se reducira el precio.
     * <ul>
     * <li>1: 4 veces menos</li>
     * <li>2: 3 veces menos</li>
     * <li>3: 2 veces menos</li>
     * </ul>
     * @param cantidad
     * @return 
     */
    @Override
    public double calcular(int cantidad) {

        double precioFinal = super.calcular(cantidad);

        switch (dias_a_caducar) {
            case 1:
                precioFinal /= 4;
                break;
            case 2:
                precioFinal /= 3;
                break;
            case 3:
                precioFinal /= 2;
                break;
        }
        
        return precioFinal;

    }

}

— No Perecedero

/**
 * Clase NoPerecedero, clase hija de Producto
 * No se ha implementado calcular, llama al del padre
 * @author DiscoDurodeRoer
 */
public class NoPerecedero extends Producto{
    
    //Atributos
    private String tipo;

    //constructores
    public NoPerecedero(String tipo, String nombre, double precio) {
        super(nombre, precio);
        this.tipo = tipo;
    }

    //Metodos
    public String getTipo() {
        return tipo;
    }

    public void setTipo(String tipo) {
        this.tipo = tipo;
    }

    @Override
    public String toString() {
        return super.toString() + " tipo=" + tipo + '}';
    }
    
    
}

— Main

public class Ejercicio_POO_DDR_09 {

    public static void main(String[] args) {
        
        //Creo que array de productos
        Producto[] productos = new Producto[3];
        
        //Creo los elementos
        productos[0] = new Producto("producto 1", 10);
        productos[1] = new Perecedero(1, "producto 2", 20);
        productos[2] = new NoPerecedero("tipo 1", "producto 3", 5);

        //Calculo el precio
        double total=0;
        for(int i=0;i<productos.length;i++){
            total += productos[i].calcular(5); //Polimorfismo
        }
        
        //Muestro el total
        System.out.println("el total es "+total);
        
    }
    
}

— Bebida

public class Bebida {
    
    private static int idActual=1;
    
    private int id;
    private double cantidad;
    private double precio;
    private String marca;
    
    public Bebida(double cantidad, double precio, String marca){
        
        this.id=idActual++;
        
        this.cantidad=cantidad;
        this.precio=precio;
        this.marca=marca;
        
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getCantidad() {
        return cantidad;
    }

    public void setCantidad(double cantidad) {
        this.cantidad = cantidad;
    }

    public double getPrecio() {
        return precio;
    }

    public void setPrecio(double precio) {
        this.precio = precio;
    }

    public String getMarca() {
        return marca;
    }

    public void setMarca(String marca) {
        this.marca = marca;
    }

    @Override
    public String toString() {
        return  "id=" + id + ", cantidad=" + cantidad + ", precio=" + precio + ", marca=" + marca + " ";
    }
    
}

— Bebida Azucarada

public class BebidaAzucarada extends Bebida {
    
    private double porcentajeAzucar;
    private boolean promocion;

    public BebidaAzucarada(double porcentajeAzucar, boolean promocion, double cantidad, double precio, String marca) {
        super(cantidad, precio, marca);
        this.porcentajeAzucar = porcentajeAzucar;
        this.promocion = promocion;
    }

    public double getPorcentajeAzucar() {
        return porcentajeAzucar;
    }

    public void setPorcentajeAzucar(double porcentajeAzucar) {
        this.porcentajeAzucar = porcentajeAzucar;
    }

    public boolean isPromocion() {
        return promocion;
    }

    public void setPromocion(boolean promocion) {
        this.promocion = promocion;
    }
    
    @Override
    public double getPrecio(){
        if(isPromocion()){
            return super.getPrecio()*0.9;
        }else{
            return super.getPrecio();
        }
    }

    @Override
    public String toString() {
        return super.toString() + "porcentajeAzucar=" + porcentajeAzucar + ", promocion=" + promocion ;
    }
    
}

— Agua mineral

public class AguaMineral extends Bebida {

    //Atributos
    private String manatial;

    //Constructores
    public AguaMineral(String manatial, double cantidad, double precio, String marca) {
        super(cantidad, precio, marca);
        this.manatial = manatial;
    }

    //Metodos
    public String getManatial() {
        return manatial;
    }

    public void setManatial(String manatial) {
        this.manatial = manatial;
    }

    @Override
    public String toString() {
        return super.toString() + "manatial=" + manatial;
    }

}

— Almacen

public class Almacen {

    //Atributos
    private Bebida[][] estanteria;

    //Constructores
    public Almacen(int filas, int columnas) {
        estanteria = new Bebida[filas][columnas];
    }

    public Almacen() {
        estanteria = new Bebida[5][5];
    }

    //Metodos
    
    /**
     * Agega una bebida, primera posicion que encuentre
     * @param b 
     */
    public void agregarBebida(Bebida b) {

        boolean encontrado = false;
        for (int i = 0; i < estanteria.length && !encontrado; i++) {
            for (int j = 0; j < estanteria[0].length && !encontrado; j++) {
                if (estanteria[i][j] == null) {
                    estanteria[i][j] = b; //inserto la bebida
                    encontrado = true; //Salgo
                }
            }
        }

        //Indico si se ha añadiddo la bebida o no
        if (encontrado) {
            System.out.println("Bebida añadida");
        } else {
            System.out.println("No se ha podido añadir la bebida");
        }

    }

    /**
     * Elimina la bebida con el id que le pasen, sino esta se indica
     * @param id 
     */
    public void eliminarBebida(int id) {

        boolean encontrado = false;
        for (int i = 0; i < estanteria.length && !encontrado; i++) {
            for (int j = 0; j < estanteria[0].length && !encontrado; j++) {
                if (estanteria[i][j] != null) {
                    if (estanteria[i][j].getId() == id) {
                        estanteria[i][j] = null; //Elimino la bebida
                        encontrado = true; //Salgo
                    }
                }
            }
        }

        //Indico si se ha eliminado
        if (encontrado) {
            System.out.println("Bebida eliminada");
        } else {
            System.out.println("No existe la bebida");
        }

    }

    /**
     * Recorro las estantenrias y muestro las bebidas
     */
    public void mostrarBebidas() {

        
        for (int i = 0; i < estanteria.length; i++) {
            for (int j = 0; j < estanteria[0].length; j++) {
                if (estanteria[i][j] != null) {//controlo nulos
                    System.out.println("fila " + i + ", columna: " + j + " Bebida: " + estanteria[i][j].toString());
                }
            }
        }

    }

    /**
     * Calculo el precio de todas las bebidas
     * @return 
     */
    public double calcularPrecioBebidas() {

        double precioTotal = 0;
        for (int i = 0; i < estanteria.length; i++) {
            for (int j = 0; j < estanteria[0].length; j++) {
                if (estanteria[i][j] != null) {//controlo nulos
                    precioTotal += estanteria[i][j].getPrecio();//acumulo el precio
                }
            }
        }

        return precioTotal;

    }

    /**
     * Calculo el precio de todas las bebidas dde una marca
     * @param marca
     * @return 
     */
    public double calcularPrecioBebidas(String marca) {

        double precioTotal = 0;
        for (int i = 0; i < estanteria.length; i++) {
            for (int j = 0; j < estanteria[0].length; j++) {
                if (estanteria[i][j] != null) {//controlo nulos

                    if (estanteria[i][j].getMarca().equalsIgnoreCase(marca)) {
                        precioTotal += estanteria[i][j].getPrecio(); //acumulo el precio
                    }

                }
            }

        }

        return precioTotal;
    }

    /**
     * Calculo el precio de todas las bebidas de una determinada columna
     * @param columna
     * @return 
     */
    public double calcularPrecioBebidas(int columna) {

        double precioTotal = 0;
        if (columna >= 0 && columna < estanteria[0].length) {

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

                if (estanteria[i][columna] != null) { //controlo nulos
                    precioTotal += estanteria[i][columna].getPrecio(); //acumulo el precio
                }

            }

        } else {
            System.out.println("La columna debe estar entre 0 y " + estanteria[0].length);
        }

        return precioTotal;

    }

}

— Main

public class Ejercicio_POO_DDR_10 {

    public static void main(String[] args) {
        
        //Creo el almacen
        Almacen a = new Almacen();
        
        Bebida b;
        
        //Añado bebidas (un poco de todo)
        //La forma de hacerlo es opcional
        for(int i=0;i<10;i++){
            switch(i%2){
                case 0:
                    b=new AguaMineral("manantial1", 1.5, 5, "bezoya");
                    a.agregarBebida(b);
                    break;
                case 1:
                    b=new BebidaAzucarada(0.2, true, 1.5, 10, "Coca Cola");
                    a.agregarBebida(b);
                    break;
            }
        }
        
        //Muestro las bebidas
        a.mostrarBebidas();
        
        //Calculo el precio de todas las bebidas
        System.out.println("Precio de todas las bebidas "+a.calcularPrecioBebidas());
        
        //Elimino una bebida en concreto
        a.eliminarBebida(4);
        
        //Muestro las bebidas
        a.mostrarBebidas();
        
        //
        System.out.println("Precio de todas las bebidas"+a.calcularPrecioBebidas());
        
        System.out.println("Precio de todas las bebidas de la marca bezoya" +a.calcularPrecioBebidas("bezoya"));
        
        System.out.println("Calcular el precio de la columna 0: "+a.calcularPrecioBebidas(0));
        
    }
    
}

— Contacto

/**
 * Representa a un contacto
 * @author Discoduroderoer
 */
public class Contacto {
    
    private String nombre;
    private int telefono;

    public Contacto(String nombre, int telefono) {
        this.nombre = nombre;
        this.telefono = telefono;
    }
    
    public Contacto(String nombre) {
        this.nombre = nombre;
        this.telefono = 0;
    }

    public String getNombre() {
        return nombre;
    }

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

    public int getTelefono() {
        return telefono;
    }

    public void setTelefono(int telefono) {
        this.telefono = telefono;
    }

    public boolean equals(Contacto c){
        
        if(this.nombre.trim().equalsIgnoreCase(c.getNombre().trim())){
            return true;
        }
        
        return false;
        
    }
    
    @Override
    public String toString() {
        return "nombre=" + nombre + ", telefono=" + telefono;
    }
    
    
}

— Agenda

/**
 * Lleva la gestion de una agenda
 * @author Discoduroderoer
 */
public class Agenda {

    //Atributos
    private Contacto[] contactos;

    //Constructores
    public Agenda() {
        this.contactos = new Contacto[10]; //por defecto
    }

    public Agenda(int tamanio) {
        this.contactos = new Contacto[tamanio]; //tamaño que nosotros queramos
    }

    //Metodos
    /**
     * Añade un contacto a la agenda
     *
     * @param c
     */
    public void aniadirContacto(Contacto c) {

        if (existeContacto(c)) { //Indico si existe el contacto
            System.out.println("El contacto con ese nombre ya existe");
        } else if (agendaLlena()) { //Indico si la agenda esta o no llena
            System.out.println("La agenda esta llena, no se pueden meter mas contactos");
        } else {

            boolean encontrado = false;
            for (int i = 0; i < contactos.length && !encontrado; i++) {
                if (contactos[i] == null) { //controlo los nulos
                    contactos[i] = c; //Inserto el contacto 
                    encontrado = true; //Indico que lo he encontrado
                }
            }

            if (encontrado) {
                System.out.println("Se ha añadido");
            } else {
                System.out.println("No se ha podido añadir");
            }
        }

    }

    /**
     * Indica si existe un contacto
     *
     * @param c
     * @return
     */
    public boolean existeContacto(Contacto c) {

        for (int i = 0; i < contactos.length; i++) {
            //Controlo nulos e indico si el contacto es el mismo
            if (contactos[i] != null && c.equals(contactos[i])) {
                return true;
            }
        }
        return false;

    }

    /**
     * Lista los contactos de la agenda
     */
    public void listarContactos() {

        if (huecosLibre() == contactos.length) {
            System.out.println("No hay contactos que mostrar");
        } else {
            for (int i = 0; i < contactos.length; i++) {
                if (contactos[i] != null) { //Controlo nulos
                    System.out.println(contactos[i]);
                }
            }
        }

    }

    /**
     * Busca un contacto por su nombre
     *
     * @param nombre
     */
    public void buscarPorNombre(String nombre) {

        boolean encontrado = false;
        for (int i = 0; i < contactos.length && !encontrado; i++) {
            //Controlo nulos y cxompruebo que es el contacto buscado (forma mas engorrosa)
            if (contactos[i] != null && contactos[i].getNombre().trim().equalsIgnoreCase(nombre.trim())) {
                System.out.println("Su telefono es " + contactos[i].getTelefono()); //muestro el telefono
                encontrado = true; //Indico que lo he encontrado
            }
        }

        if (!encontrado) {
            System.out.println("No se ha encontrado el contacto");
        }

    }

    /**
     * Indica si la agenda esta llena o no
     *
     * @return
     */
    public boolean agendaLlena() {

        for (int i = 0; i < contactos.length; i++) {
            if (contactos[i] == null) { //Controlo nulos
                return false; //indico que no esta llena
            }
        }

        return true; //esta llena

    }

    /**
     * Elimina el contacto de la agenda
     *
     * @param c
     */
    public void eliminarContacto(Contacto c) {

        boolean encontrado = false;
        for (int i = 0; i < contactos.length && !encontrado; i++) {
            if (contactos[i] != null && contactos[i].equals(c)) {
                contactos[i] = null; //Controlo nulos
                encontrado = true; //Indico que lo he encontrado
            }
        }

        if (encontrado) {
            System.out.println("Se ha eliminado el contacto");
        } else {
            System.out.println("No se ha eliminado el contacto");

        }

    }

    /**
     * Indica cuantos contactos más podemos meter
     *
     * @return
     */
    public int huecosLibre() {

        int contadorLibres = 0;
        for (int i = 0; i < contactos.length; i++) {
            if (contactos[i] == null) { //Controlo nulos
                contadorLibres++; //Acumulo
            }
        }

        return contadorLibres;

    }

}

— Main

import java.util.InputMismatchException;
import java.util.Scanner;

public class Ejercicio_POO_DDR_11 {

    public static void main(String[] args) {

        Scanner sn = new Scanner(System.in);
        sn.useDelimiter("\n");
        boolean salir = false;
        int opcion; //Guardaremos la opcion del usuario

        Agenda agendaTelefonica = new Agenda(3);
        String nombre;
        int telefono;

        Contacto c;

        while (!salir) {

            System.out.println("1. Añadir contacto");
            System.out.println("2. Listar contactos");
            System.out.println("3. Buscar contacto");
            System.out.println("4. Existe contacto");
            System.out.println("5. Eliminar contacto");
            System.out.println("6. Contactos disponibles");
            System.out.println("7. Agenda llena");
            System.out.println("8. Salir");
            try {
                System.out.println("Escribe una de las opciones");
                opcion = sn.nextInt();

                switch (opcion) {
                    case 1:

                        //Pido valores
                        System.out.println("Escribe un nombre");
                        nombre = sn.next();

                        System.out.println("Escribe un telefono");
                        telefono = sn.nextInt();

                        //Creo el contacto
                        c = new Contacto(nombre, telefono);

                        agendaTelefonica.aniadirContacto(c);

                        break;
                    case 2:

                        agendaTelefonica.listarContactos();

                        break;
                    case 3:

                        //pido el nombre
                        System.out.println("Escribe un nombre");
                        nombre = sn.next();

                        agendaTelefonica.buscarPorNombre(nombre);

                        break;
                    case 4:

                        //pido el nombre
                        System.out.println("Escribe un nombre");
                        nombre = sn.next();

                        //Creo el contacto auxiliar
                        c = new Contacto(nombre, 0);

                        if (agendaTelefonica.existeContacto(c)) {
                            System.out.println("Existe contacto");
                        } else {
                            System.out.println("No existe contacto");
                        }

                        break;
                    case 5:

                        //pido el nombre
                        System.out.println("Escribe un nombre");
                        nombre = sn.next();

                        //Creo el contacto auxiliar
                        c = new Contacto(nombre, 0);

                        agendaTelefonica.eliminarContacto(c);

                        break;
                    case 6:

                        System.out.println("Hay " + agendaTelefonica.huecosLibre() + " contactos libre");

                        break;
                    case 7:

                        //como devuelve un booleano, lo meto en un if
                        if (agendaTelefonica.agendaLlena()) {
                            System.out.println("La agenda esta llena");
                        } else {
                            System.out.println("Aun puedes meter contactoss");
                        }

                        break;
                    case 8:
                        salir = true;
                        break;
                    default:
                        System.out.println("Solo números entre 1 y 8");
                }

            } catch (InputMismatchException e) {
                System.out.println("Debes insertar un número");
                sn.next();
            }

        }

    }

}

— Palos baraja española

public enum PalosBarajaEspañola {
    OROS,
    COPAS,
    ESPADAS,
    BASTOS;
}

— Palos baraja francesa

public enum PalosBarajaFrancesa { 
    DIAMANTES,
    PICAS,
    TREBOLES,
    CORAZONES;
}

— Carta

/**
 * Clase Carta
 * @author Disco Duro de Roer
 */
public class Carta<T> {
    
    //Atributos
    private int numero;
    private T palo;

    public int getNumero() {
        return numero;
    }

    public T getPalo() {
        return palo;
    }
    
    //Constructor
    public Carta(int numero, T palo) {
        this.numero = numero;
        this.palo = palo;
    }

    @Override
    public String toString() {
        
        String estado="";
        String nombreFigura="";
        
        if(palo.getClass().getSimpleName().equals("PalosBarajaEspañola")){
            
            switch(numero){
                case 1:
                    nombreFigura="As";
                    break;
                case 10:
                    nombreFigura="Sota";
                    break;
                case 11:
                    nombreFigura="Caballo";
                    break;
                case 12:
                    nombreFigura="Rey";
                    break;
                default:
                    nombreFigura=numero+"";
            }
            
            
            
            
        }else if(palo.getClass().getSimpleName().equals("PalosBarajaFrancesa")){
            
            switch(numero){
                case 1:
                    nombreFigura="As";
                    break;
                case 11:
                    nombreFigura="Jota";
                    break;
                case 12:
                    nombreFigura="Reina";
                    break;
                case 13:
                    nombreFigura="Rey";
                    break;
                default:
                    nombreFigura=numero+"";
            }
            
        }
        
        estado = nombreFigura + " de "+ palo;
        
        return estado;
        
    }
    
}

— Baraja

/**
 * Clase Baraja
 *
 * @author Disco Duro de Roer
 */
public abstract class Baraja<T> {

    //Atributos
    protected Carta<T> cartas[];
    protected int posSiguienteCarta;
    protected int numCartas;
    protected int cartasPorPalo;

    public Baraja() {
        this.posSiguienteCarta = 0;
    }

    /**
     * Metodo abstracto crearBaraja
     */
    public abstract void crearBaraja();

    /**
     * Baraja todas las cartas
     */
    public void barajar() {

        int posAleatoria = 0;
        Carta c;

        //Recorro las cartas
        for (int i = 0; i < cartas.length; i++) {

            posAleatoria = Metodos.generaNumeroEnteroAleatorio(0, numCartas - 1);

            //intercambio
            c = cartas[i];
            cartas[i] = cartas[posAleatoria];
            cartas[posAleatoria] = c;

        }

        //La posición vuelve al inicio
        this.posSiguienteCarta = 0;

    }

    /**
     * Devuelve la casta donde se encuentre "posSiguienteCarta"
     *
     * @return carta del arreglo
     */
    public Carta siguienteCarta() {

        Carta c = null;

        if (posSiguienteCarta == numCartas) {
            System.out.println("Ya no hay mas cartas, barajea de nuevo");
        } else {
            c = cartas[posSiguienteCarta++];
        }

        return c;

    }

    /**
     * Devuelve un numero de cartas. Controla si hay mas cartas de las que se
     * piden
     *
     * @param numCartas
     * @return
     */
    public Carta[] darCartas(int numCartas) {

        if (numCartas > numCartas) {
            System.out.println("No se puede dar mas cartas de las que hay");
        } else if (cartasDisponible() < numCartas) {
            System.out.println("No hay suficientes cartas que mostrar");
        } else {

            Carta[] cartasDar = new Carta[numCartas];

            //recorro el array que acabo de crear para rellenarlo
            for (int i = 0; i < cartasDar.length; i++) {
                cartasDar[i] = siguienteCarta(); //uso el metodo anterior
            }

            //Lo devuelvo
            return cartasDar;

        }

        //solo en caso de error
        return null;

    }

    /**
     * Indica el numero de cartas que hay disponibles
     *
     * @return
     */
    public int cartasDisponible() {
        return numCartas - posSiguienteCarta;
    }

    /**
     * Muestro las cartas que ya han salido
     */
    public void cartasMonton() {

        if (cartasDisponible() == numCartas) {
            System.out.println("No se ha sacado ninguna carta");
        } else {
            //Recorro desde 0 a la posSiguienteCarta
            for (int i = 0; i < posSiguienteCarta; i++) {
                System.out.println(cartas[i]);
            }
        }

    }

    /**
     * Muestro las cartas que aun no han salido
     */
    public void mostrarBaraja() {

        if (cartasDisponible() == 0) {
            System.out.println("No hay cartas que mostrar");
        } else {
            for (int i = posSiguienteCarta; i < cartas.length; i++) {
                System.out.println(cartas[i]);
            }
        }

    }

}

— Baraja Española

/**
 * Baraja Española
 * @author Disco Duro de Roer
 */
public class BarajaEspañola extends Baraja {

    private boolean incluye_8_9;

    public BarajaEspañola(boolean incluye_8_9) {
        super();

        this.incluye_8_9 = incluye_8_9;

        if (incluye_8_9) {
            numCartas = 48;
            cartasPorPalo = 12;
        } else {
            numCartas = 40;
            cartasPorPalo = 10;
        }

        crearBaraja(); //Creamos la baraja
        super.barajar(); // barajamos la baraja
    }

    @Override
    public void crearBaraja() {

        this.cartas = (Carta<PalosBarajaEspañola>[]) new Carta[numCartas];

        PalosBarajaEspañola[] palos = PalosBarajaEspañola.values();

        //Recorro los palos
        for (int i = 0; i < palos.length; i++) {

            //Recorro los numeros
            for (int j = 0; j < cartasPorPalo; j++) { if (incluye_8_9) { cartas[((i * cartasPorPalo) + j)] = new Carta(j + 1, palos[i]); } else { //Las posiciones del 8 y del 9 son el 7 y el 8 (emepzamos en 8) if (j >= 7) {
                        //Solo para la sota, caballo y rey
                        cartas[((i * cartasPorPalo) + j)] = new Carta(j + 3, palos[i]);
                    } else {
                        //Para los casos de 1 a 7
                        cartas[((i * cartasPorPalo) + j)] = new Carta(j + 1, palos[i]);
                    }
                }

            }

        }

    }

}

–Baraja Francesa

/**
 * Baraja francesa
 * @author Disco Duro de Roer
 */
public class BarajaFrancesa extends Baraja {

    public BarajaFrancesa() {
        super();

        this.numCartas = 52;
        this.cartasPorPalo = 13;

        crearBaraja(); //Creamos la baraja
        super.barajar(); // barajamos la baraja
    }

    @Override
    public void crearBaraja() {

        this.cartas = (Carta<PalosBarajaFrancesa>[]) new Carta[numCartas];

        PalosBarajaFrancesa[] palos = PalosBarajaFrancesa.values();

        //Recorro los palos
        for (int i = 0; i < palos.length; i++) {

            //Recorro los numeros
            for (int j = 0; j < cartasPorPalo; j++) {
                cartas[((i * cartasPorPalo) + j)] = new Carta(j + 1, palos[i]);
            }

        }

    }

    public boolean cartaRoja(Carta<PalosBarajaFrancesa> c) {
        return c.getPalo() == PalosBarajaFrancesa.CORAZONES || c.getPalo() == PalosBarajaFrancesa.DIAMANTES;
    }

    public boolean cartaNegra(Carta<PalosBarajaFrancesa> c) {
        return c.getPalo() == PalosBarajaFrancesa.TREBOLES || c.getPalo() == PalosBarajaFrancesa.PICAS;
    }

}

–Metodos

/**
 * Clase Metodos, contiene métodos estaricos sueltos
 * @author Disco Duro de Roer
 */
public class Metodos {

    public static int generaNumeroEnteroAleatorio(int minimo, int maximo) {
        int num = (int) (Math.random() * (minimo - (maximo + 1)) + (maximo + 1));
        return num;
    }

}

— Main

public class Ejercicio_POO_DDR_12 {

    public static void main(String[] args) {
        
        //Creamos la baraja
        BarajaFrancesa b = new BarajaFrancesa();
        
        //Mostramos las cartas disponibles (40)
        System.out.println("Hay "+b.cartasDisponible()+" cartas disponibles");
       
        //Saco una carta
        b.siguienteCarta();
        
        //Saco 5 cartas
        b.darCartas(5);
        
        //Mostramos las cartas disponibles (34)
        System.out.println("Hay "+b.cartasDisponible()+" cartas disponibles");
       
        System.out.println("Cartas sacadas de momento");
        
        b.cartasMonton();
        
        
        //Barajamos de nuevo
        b.barajar();
       
        //Saco 5 cartas
        Carta[] c = b.darCartas(5);
        
        System.out.println("Cartas sacadas despues de barajar ");
        for(int i=0;i<c.length;i++){
            System.out.println(c[i]);
        }
        
    }
    
}

— Nodo

/**
 * Clase Nodo
 *
 * @author DiscoDurodeRoer
 * @param <T>
 */
public class Nodo<T> {

    //Atributos
    private T elemento;
    private Nodo<T> siguiente; //Apunta al siguiente nodo

    //Contructor
    public Nodo(T elemento, Nodo<T> siguiente) {
        this.elemento = elemento;
        this.siguiente = siguiente;
    }

    //Metodos
    public T getElemento() {
        return elemento;
    }

    public void setElemento(T elemento) {
        this.elemento = elemento;
    }

    public Nodo<T> getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(Nodo<T> siguiente) {
        this.siguiente = siguiente;
    }

    @Override
    public String toString() {
        return elemento + "\n";
    }

    
    
}

— Lista dinamica

/**
 * Lista Dinamica Version 2.0
 *
 * @author DiscoDurodeRoer
 */
public class ListaDinamica<T> {

    //Atributos
    private Nodo<T> primero;
    private Nodo<T> ultimo;
    private int tamanio;

    public ListaDinamica() {
        primero = null;
        ultimo = null;
        tamanio = 0;
    }

    /**
     * Indica si esta la lista vacia o no
     *
     * @return
     */
    public boolean isEmpty() {
        return tamanio == 0;
    }

    /**
     * Devuelve el tamaño de la lista
     *
     * @return
     */
    public int size() {
        return tamanio;
    }

    /**
     * Devuelve el elemento en la posicion indicada
     *
     * @param index
     * @return
     */
    public T get(int index) {

        //si esta vacio o el indice no es correcto, devuelve null
        if (isEmpty() || (index < 0 || index >= size())) {
            return null;
        } else if (index == 0) {
            return getFirst(); //Cojo el primero
        } else if (index == size() - 1) {
            return getLast(); //Cojo el ultimo
        } else {

            //Uso la funcion getNode para coger el nodo deseado
            Nodo<T> buscado = getNode(index);

            return buscado.getElemento();

        }

    }

    /**
     * Devuelve el primer elemento, null si esta vacia la lista
     *
     * @return
     */
    public T getFirst() {
        //Si esta vacia, no hay primero que coger
        if (isEmpty()) {
            return null;
        } else {
            return primero.getElemento();
        }
    }

    /**
     * Devuelve el ultimo elemento, null si esta vacia la lista
     *
     * @return
     */
    public T getLast() {
        //Si esta vacia, no hay ultimo que coger
        if (isEmpty()) {
            return null;
        } else {
            return ultimo.getElemento();
        }
    }

    /**
     * Devuelve el nodo completo de una posicion concreta
     *
     * @param index
     * @return
     */
    private Nodo<T> getNode(int index) {

        //si esta vacio o el indice no es correcto, devuelve null
        if (isEmpty() || (index < 0 || index >= size())) {
            return null;
        } else if (index == 0) {
            return primero; //devuelvo el primero
        } else if (index == size() - 1) {
            return ultimo; //devuelvo el ultimo
        } else {

            Nodo<T> buscado = primero;

            //Busco el nodo deseado con un recorrido
            int contador = 0;
            while (contador < index) {
                contador++;
                buscado = buscado.getSiguiente();
            }

            //Me devuelve el buscado
            return buscado;

        }

    }

    /**
     * Añade un elemento al final de la lista
     *
     * @param elemento
     * @return elemento añadido
     */
    public T addLast(T elemento) {

        Nodo<T> aux;

        //Si esta vacia, hago lo mismo que si fuera añadir el primero
        if (isEmpty()) {
            return addFirst(elemento);
        } else {

            //Hago el intercambio
            aux = new Nodo<>(elemento, null);

            ultimo.setSiguiente(aux);
            ultimo = aux;

        }

        //Aumento el tamanño
        tamanio++;
        return ultimo.getElemento();

    }

    /**
     * Añade el elemento al principio de la lista
     *
     * @param elemento
     * @return elemento añadido
     */
    public T addFirst(T elemento) {

        Nodo<T> aux;

        //si esta vacia, el nodo será el primero y ultimo
        if (isEmpty()) {
            aux = new Nodo<>(elemento, null);
            primero = aux;
            ultimo = aux;
        } else {
            //Hago el intercambio
            Nodo<T> primeroActual = primero;
            aux = new Nodo<>(elemento, primeroActual);
            primero = aux;

        }

        //Aumento el tamanño
        tamanio++;
        return primero.getElemento();

    }

    /**
     * Añade un elemento en una posicion indicada
     *
     * @param elemento
     * @param index debe ser un indice valido
     * @return elemento añadido
     */
    public T add(T elemento, int index) {

        //si esta vacio o el indice no es correcto, devuelve null
        if (index == 0) {
            return addFirst(elemento); //Añade en la primera posicion
        } else if (index == size()) {
            return addLast(elemento); //añade en la ultima posicion
        } else if ((index < 0 || index >= size())) {
            return null;
        } else {

            //Cojo el anterior nodo al que estoy buscando
            Nodo<T> buscado_anterior = getNode(index - 1);

            //Cojo el nodo de la posicion indicada
            Nodo<T> buscado_actual = getNode(index);

            //Creo el nuevo novo, este apuntara al de la posicion actual
            Nodo<T> aux = new Nodo<>(elemento, buscado_actual);

            //el nodo anterior apunta a nuestro nuevo nodo
            buscado_anterior.setSiguiente(aux);

            //Aumento el tamaño
            tamanio++;
            return getNode(index).getElemento();

        }

    }

    /**
     * Devuelve el estado de la lista
     *
     * @return
     */
    public String toString() {

        String contenido = "";

        //Si esta vacia, lo indica
        if (isEmpty()) {
            contenido = "Lista vacia";
        } else {

            Nodo<T> aux = primero;

            //Recorre la lista, mostrando el contenido
            while (aux != null) {
                contenido += aux.toString();
                aux = aux.getSiguiente();
            }

        }

        return contenido;

    }

    /**
     * Indica si existe el elemento indicado
     *
     * @param elemento
     * @return
     */
    public boolean exists(T elemento) {

        //Si esta vacio, devuelve el false
        if (isEmpty()) {
            return false;
        } else {

            Nodo<T> aux = primero;

            //Recorremos la lista
            while (aux != null) {
                if (elemento.equals(aux.getElemento())) { //Mejor .equals que ==
                    return true; //Existe
                }
                aux = aux.getSiguiente();
            }

            //Si no lo encuentra devuelve false
            return false;

        }
    }

    /**
     * Indica la posición del elemento
     *
     * @param elemento
     * @return
     */
    public int indexOf(T elemento) {

        //Si esta vacio, devuelvemos -1
        if (isEmpty()) {
            return -1;
        } else {

            Nodo<T> aux = primero;

            int posicion = 0;
            while (aux != null) {
                if (elemento.equals(aux.getElemento())) { //Mejor .equals que ==
                    return posicion; //Existe
                }
                posicion++;
                aux = aux.getSiguiente();
            }
            //Si no lo encuentra devuelve -1
            return -1;

        }

    }

    /**
     * Elimina el primer elemento de la lista
     *
     * @return
     */
    public T removeFirst() {

        //Si la lista esta vacia, devolvemos null
        if (isEmpty()) {
            return null;
        } else {

            //Guardo el elemento antes
            T elemento = primero.getElemento();

            //Cojo el segundo
            Nodo<T> aux = primero.getSiguiente();
            primero = null; //Lo marco como null para el recolector
            primero = aux; //Este es mi nuevo primero

            //En caso de que borremos el ultimo elemento,el ultimo también
            if (size() == 1) {
                ultimo = null;
            }

            tamanio--;

            return elemento;

        }

    }

    /**
     * Borra el ultimo elemento de la lista
     *
     * @return
     */
    public T removeLast() {

        if (isEmpty()) {
            return null;
        } else {

            //Coge el elemento antes de borrar
            T elemento = ultimo.getElemento();

            //Cojo el penultimo
            Nodo<T> aux = getNode(size() - 2);

            //En caso de que sea null
            //Hay 1 o dos elementos
            if (aux == null) {

                //marco el ultimo como nulo
                ultimo = null;
                //Si hay dos, el primero y el ultimo seran el mismo
                //Si hay 1 elemento, significa que borramos la lista
                if (size() == 2) {
                    ultimo = primero;
                } else {
                    primero = null;
                }

            } else {
                //el penultimo es el nuevo ultimo 
                //y le ponemos como siguiente nulo
                ultimo = null;
                ultimo = aux;
                ultimo.setSiguiente(null);
            }

            tamanio--;

            return elemento;

        }

    }

    /**
     * Elimina el nodo de la lista en una posicion concreta
     *
     * @param index
     * @return
     */
    public T remove(int index) {
        //si esta vacio o el indice no es correcto, devuelve null
        if (isEmpty() || (index < 0 || index >= size())) {
            return null;
        } else if (index == 0) {
            return removeFirst();
        } else if (index == size() - 1) {
            return removeLast();
        } else {

            //Cojo el nodo anterior al que quiero borrar
            Nodo<T> nodo_anterior = getNode(index - 1);

            //Cojo el nodo que quiero borrar
            Nodo<T> nodo_actual = getNode(index);

            //Cojo el elemento antes de borrar
            T elemento = nodo_actual.getElemento();

            //Cojo el nodo siguiente al que quiero borrar
            Nodo<T> nodo_siguiente = nodo_actual.getSiguiente();

            //Lo marco para borrar para el recolector
            nodo_actual = null;

            //El nodo anterior apunta al nodo siguiente
            nodo_anterior.setSiguiente(nodo_siguiente);

            tamanio--;

            return elemento;

        }
    }

    /**
     * Modifico el elemento de una posicion No afecta a la estructura de la
     * lista
     *
     * @param elemento
     * @param index
     * @return
     */
    public T modify(T elemento, int index) {

        //si esta vacio o el indice no es correcto, devuelve null
        if (isEmpty() || (index < 0 || index >= size())) {
            return null;
        } else {

            //Nodo actual
            Nodo<T> aux = getNode(index);

            //modifico
            aux.setElemento(elemento);

            return aux.getElemento();

        }

    }

}

— Leer

import java.util.InputMismatchException;
import java.util.Locale;
import java.util.Scanner;

/**
 * Clase para gestionar entrada de datos y validaciones
 *
 * @author DiscoDurodeRoer
 */
public class Leer {

    //Scanner para pedir datos
    private Scanner sc;

    /**
     * Por defecto
     */
    public Leer() {
        sc = new Scanner(System.in);
        sc.useDelimiter("\n"); //Usado para nextLine()
        sc.useLocale(Locale.US); // Para double
    }

    /**
     * Nos pide un valor númerico, valida si es un valor numerico
     *
     * @return numero entero byte introducido por el usuario
     */
    public byte pedirByte() {

        byte num = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println("Introduce un numero entero byte");
                num = sc.nextByte();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            //En caso de error, muestro el error
            if (!correcto) {
                System.out.println("Error, introducce un numero entero byte");
            }

        } while (!correcto);

        return num;
    }

    /**
     * Nos pide un valor númerico, valida si es un valor numerico
     *
     * @param mensaje
     * @return numero entero byte introducido por el usuario
     */
    public byte pedirByte(String mensaje) {

        byte num = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                num = sc.nextByte();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            //En caso de error, muestro el error
            if (!correcto) {
                System.out.println("Error, introducce un numero entero byte");
            }

        } while (!correcto);

        return num;
    }

    /**
     * Nos pide un valor númerico, valida si es un valor numerico
     *
     * @param mensaje
     * @param mensajeError
     * @return numero entero byte introducido por el usuario
     */
    public byte pedirByte(String mensaje, String mensajeError) {

        byte num = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                num = sc.nextByte();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            //En caso de error, muestro el error
            if (!correcto) {
                System.out.println(mensajeError);
            }

        } while (!correcto);

        return num;
    }

    /**
     * Pide un valor entero positivo, valida que sea un numero y que sea
     * positivo
     *
     * @return numero entero byte positivo introducido por el usuario
     */
    public byte pedirBytePositivo() {

        byte num;
        do {
            try {
                System.out.println("Introduce un numero entero byte positivo");
                num = sc.nextByte();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno negativo
                num = -1;
                sc.next();
            }

            if (num < 0) {
                System.out.println("Error, introducce un numero entero byte positivo");
            }

        } while (num < 0);

        return num;
    }

    /**
     * Pide un valor entero positivo, valida que sea un numero y que sea
     * positivo
     *
     * @param mensaje
     * @return numero entero byte positivo introducido por el usuario
     */
    public byte pedirBytePositivo(String mensaje) {

        byte num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextByte();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno negativo
                num = -1;
                sc.next();
            }

            if (num < 0) {
                System.out.println("Error, introducce un numero entero byte positivo");
            }

        } while (num < 0);

        return num;
    }

    /**
     * Pide un valor entero positivo, valida que sea un numero y que sea
     * positivo
     *
     * @param mensaje
     * @param mensajeError
     * @return numero entero byte positivo introducido por el usuario
     */
    public byte pedirBytePositivo(String mensaje, String mensajeError) {

        byte num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextByte();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno negativo
                num = -1;
                sc.next();
            }

            if (num < 0) {
                System.out.println(mensajeError);
            }

        } while (num < 0);

        return num;
    }

    /**
     * Pide un numero entero negativo, valida que sea un numero y sea negativo
     *
     * @return numero entero byte negativo introducido por el usuario
     */
    public byte pedirByteNegativo() {
        byte num;
        do {
            try {
                System.out.println("Introduce un numero entero byte negativo");
                num = sc.nextByte();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno positivo
                num = 1;
                sc.next();
            }

            if (num >= 0) {
                System.out.println("Error, introducce un numero entero byte negativo");
            }

        } while (num >= 0);

        return num;
    }

    /**
     * Pide un numero entero negativo, valida que sea un numero y sea negativo
     *
     * @param mensaje
     * @return numero entero byte negativo introducido por el usuario
     */
    public byte pedirByteNegativo(String mensaje) {
        byte num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextByte();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno positivo
                num = 1;
                sc.next();
            }

            if (num >= 0) {
                System.out.println("Error, introducce un numero entero byte negativo");
            }

        } while (num >= 0);

        return num;
    }

    /**
     * Pide un numero entero negativo, valida que sea un numero y sea negativo
     *
     * @param mensaje
     * @param mensajeError
     * @return numero entero byte negativo introducido por el usuario
     */
    public byte pedirByteNegativo(String mensaje, String mensajeError) {
        byte num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextByte();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno positivo
                num = 1;
                sc.next();
            }

            if (num >= 0) {
                System.out.println(mensajeError);
            }

        } while (num >= 0);

        return num;
    }

    /**
     * Pide un numero entre dos numeros que le pasamos
     *
     * @param minimo
     * @param maximo
     * @return numero entero byte introducido por el usuario
     */
    public byte pedirByteRango(byte minimo, byte maximo) {
        byte num;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            byte aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println("Introduce un numero byte entre " + minimo + " y " + maximo);
                num = sc.nextByte();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como un numero no valido
                num = (byte) (maximo + 1);
                sc.next();
            }

            if (!(num >= minimo && num <= maximo)) {
                System.out.println("Error, Introduce un numero byte entre " + minimo + " y " + maximo);
            }

        } while (!(num >= minimo && num <= maximo));

        return num;
    }

    /**
     * Pide un numero entre dos numeros que le pasamos
     *
     * @param minimo
     * @param maximo
     * @param mensaje
     * @return numero entero byte introducido por el usuario
     */
    public byte pedirByteRango(byte minimo, byte maximo, String mensaje) {
        byte num;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            byte aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println(mensaje);
                num = sc.nextByte();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como un numero no valido
                num = (byte) (maximo + 1);
                sc.next();
            }

            if (!(num >= minimo && num <= maximo)) {
                System.out.println("Error, Introduce un numero byte entre " + minimo + " y " + maximo);
            }

        } while (!(num >= minimo && num <= maximo));

        return num;
    }

    /**
     * Pide un numero entre dos numeros que le pasamos
     *
     * @param minimo
     * @param maximo
     * @param mensaje
     * @param mensajeError
     * @return numero entero byte introducido por el usuario
     */
    public byte pedirByteRango(byte minimo, byte maximo, String mensaje, String mensajeError) {
        byte num;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            byte aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println(mensaje);
                num = sc.nextByte();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como un numero no valido
                num = (byte) (maximo + 1);
                sc.next();
            }

            if (!(num >= minimo && num <= maximo)) {
                System.out.println(mensajeError);
            }

        } while (!(num >= minimo && num <= maximo));

        return num;
    }

    /**
     * Nos pide un valor númerico, valida si es un valor numerico
     *
     * @return numero entero introducido por el usuario
     */
    public int pedirInt() {

        int num = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println("Introduce un numero entero integer");
                num = sc.nextInt();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            //En caso de error, muestro el error
            if (!correcto) {
                System.out.println("Error, introducce un numero entero integer");
            }

        } while (!correcto);

        return num;
    }

    /**
     * Nos pide un valor númerico, valida si es un valor numerico
     *
     * @param mensaje
     * @return numero entero introducido por el usuario
     */
    public int pedirInt(String mensaje) {

        int num = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                num = sc.nextInt();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            //En caso de error, muestro el error
            if (!correcto) {
                System.out.println("Error, introducce un numero entero integer");
            }

        } while (!correcto);

        return num;
    }

    /**
     * Nos pide un valor númerico, valida si es un valor numerico
     *
     * @param mensaje
     * @param mensajeError
     * @return numero entero introducido por el usuario
     */
    public int pedirInt(String mensaje, String mensajeError) {

        int num = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                num = sc.nextInt();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            //En caso de error, muestro el error
            if (!correcto) {
                System.out.println(mensajeError);
            }

        } while (!correcto);

        return num;
    }

    /**
     * Pide un valor entero positivo, valida que sea un numero y que sea
     * positivo
     *
     * @return numero entero positivo introducido por el usuario
     */
    public int pedirIntPositivo() {

        int num;
        do {
            try {
                System.out.println("Introduce un numero entero positivo integer");
                num = sc.nextInt();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno negativo
                num = -1;
                sc.next();
            }

            if (num < 0) {
                System.out.println("Error, introducce un numero entero positivo integer");
            }

        } while (num < 0);

        return num;
    }

    /**
     * Pide un valor entero positivo, valida que sea un numero y que sea
     * positivo
     *
     * @param mensaje
     * @return numero entero positivo introducido por el usuario
     */
    public int pedirIntPositivo(String mensaje) {

        int num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextInt();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno negativo
                num = -1;
                sc.next();
            }

            if (num < 0) {
                System.out.println("Error, introducce un numero entero positivo integer");
            }

        } while (num < 0);

        return num;
    }

    /**
     * Pide un valor entero positivo, valida que sea un numero y que sea
     * positivo
     *
     * @param mensaje
     * @param mensajeError
     * @return numero entero positivo introducido por el usuario
     */
    public int pedirIntPositivo(String mensaje, String mensajeError) {

        int num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextInt();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno negativo
                num = -1;
                sc.next();
            }

            if (num < 0) {
                System.out.println(mensajeError);
            }

        } while (num < 0);

        return num;
    }

    /**
     * Pide un numero entero negativo, valida que sea un numero y sea negativo
     *
     * @return numero entero negativo introducido por el usuario
     */
    public int pedirIntNegativo() {
        int num;
        do {
            try {
                System.out.println("Introduce un numero entero negativo integer");
                num = sc.nextInt();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno positivo
                num = 1;
                sc.next();
            }

            if (num >= 0) {
                System.out.println("Error, introducce un numero entero negativo integer");
            }

        } while (num >= 0);

        return num;
    }

    /**
     * Pide un numero entero negativo, valida que sea un numero y sea negativo
     *
     * @param mensaje
     * @return numero entero negativo introducido por el usuario
     */
    public int pedirIntNegativo(String mensaje) {
        int num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextInt();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno positivo
                num = 1;
                sc.next();
            }

            if (num >= 0) {
                System.out.println("Error, introducce un numero entero negativo integer");
            }

        } while (num >= 0);

        return num;
    }

    /**
     * Pide un numero entero negativo, valida que sea un numero y sea negativo
     *
     * @param mensaje
     * @param mensajeError
     * @return numero entero negativo introducido por el usuario
     */
    public int pedirIntNegativo(String mensaje, String mensajeError) {
        int num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextInt();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno positivo
                num = 1;
                sc.next();
            }

            if (num >= 0) {
                System.out.println(mensajeError);
            }

        } while (num >= 0);

        return num;
    }

    /**
     * Pide un numero entre dos numeros que le pasamos
     *
     * @param minimo
     * @param maximo
     * @return numero entero introducido por el usuario
     */
    public int pedirIntRango(int minimo, int maximo) {
        int num;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            int aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println("Introduce un numero integer entre " + minimo + " y " + maximo);
                num = sc.nextInt();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como un numero no valido
                num = maximo + 1;
                sc.next();
            }

            if (!(num >= minimo && num <= maximo)) {
                System.out.println("Error, Introduce un numero integer entre " + minimo + " y " + maximo);
            }

        } while (!(num >= minimo && num <= maximo));

        return num;
    }

    /**
     * Pide un numero entre dos numeros que le pasamos
     *
     * @param minimo
     * @param maximo
     * @param mensaje
     * @return numero entero introducido por el usuario
     */
    public int pedirIntRango(int minimo, int maximo, String mensaje) {
        int num;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            int aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println(mensaje);
                num = sc.nextInt();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como un numero no valido
                num = maximo + 1;
                sc.next();
            }

            if (!(num >= minimo && num <= maximo)) {
                System.out.println("Error, Introduce un numero integer entre " + minimo + " y " + maximo);
            }

        } while (!(num >= minimo && num <= maximo));

        return num;
    }

    /**
     * Pide un numero entre dos numeros que le pasamos
     *
     * @param minimo
     * @param maximo
     * @param mensaje
     * @param mensajeError
     * @return numero entero introducido por el usuario
     */
    public int pedirIntRango(int minimo, int maximo, String mensaje, String mensajeError) {
        int num;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            int aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println(mensaje);
                num = sc.nextInt();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como un numero no valido
                num = maximo + 1;
                sc.next();
            }

            if (!(num >= minimo && num <= maximo)) {
                System.out.println(mensajeError);
            }

        } while (!(num >= minimo && num <= maximo));

        return num;
    }

    /**
     * Pide una cadena
     *
     * @return cadena introducida por el usuario
     */
    public String pedirString() {

        System.out.println("Introduce una cadena");
        String cadena = sc.next();

        return cadena;

    }

    /**
     * Pide una cadena
     *
     * @param mensaje
     * @return cadena introducida por el usuario
     */
    public String pedirString(String mensaje) {

        System.out.println(mensaje);
        String cadena = sc.next();

        return cadena;

    }

    /**
     * Pide una cadena con una longitud maxima
     *
     * @param longitudMaxima
     * @return cadena introducida por el usuario
     */
    public String pedirString(int longitudMaxima) {

        String cadena = "";
        do {
            System.out.println("Introduce una cadena");
            cadena = sc.next();
            
            if(!(cadena.length() < longitudMaxima)){
                System.out.println("Error, la longitud maxima es "+longitudMaxima+" caracteres");
            }
            
        } while (!(cadena.length() < longitudMaxima));

        return cadena;

    }

    /**
     * Pide una cadena con una longitud maxima
     *
     * @param longitudMaxima
     * @param mensaje
     * @return cadena introducida por el usuario
     */
    public String pedirString(int longitudMaxima, String mensaje) {

        String cadena = "";
        do {
            System.out.println(mensaje);
            cadena = sc.next();
            
            if(!(cadena.length() < longitudMaxima)){
                System.out.println("Error, la longitud maxima es "+longitudMaxima+" caracteres");
            }
            
        } while (!(cadena.length() < longitudMaxima));

        return cadena;

    }
    
    /**
     * Pide una cadena con una longitud maxima
     *
     * @param longitudMaxima
     * @param mensaje
     * @param mensajeError
     * @return cadena introducida por el usuario
     */
    public String pedirString(int longitudMaxima, String mensaje, String mensajeError) {

        String cadena = "";
        do {
            System.out.println(mensaje);
            cadena = sc.next();
            
            if(!(cadena.length() < longitudMaxima)){
                System.out.println(mensajeError);
            }
            
        } while (!(cadena.length() < longitudMaxima));

        return cadena;

    }

    /**
     * Nos pide un valor númerico, valida si es un valor numerico
     *
     * @return numero entero introducido por el usuario
     */
    public long pedirLong() {

        long num = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println("Introduce un numero entero long");
                num = sc.nextLong();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            //En caso de error, muestro el error
            if (!correcto) {
                System.out.println("Error, introducce un numero entero long");
            }

        } while (!correcto);

        return num;
    }

    /**
     * Nos pide un valor númerico, valida si es un valor numerico
     *
     * @param mensaje
     * @return numero entero introducido por el usuario
     */
    public long pedirLong(String mensaje) {

        long num = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                num = sc.nextLong();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            //En caso de error, muestro el error
            if (!correcto) {
                System.out.println("Error, introducce un numero entero long");
            }

        } while (!correcto);

        return num;
    }

    /**
     * Nos pide un valor númerico, valida si es un valor numerico
     *
     * @param mensaje
     * @param mensajeError
     * @return numero entero introducido por el usuario
     */
    public long pedirLong(String mensaje, String mensajeError) {

        long num = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                num = sc.nextLong();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            //En caso de error, muestro el error
            if (!correcto) {
                System.out.println(mensajeError);
            }

        } while (!correcto);

        return num;
    }

    /**
     * Pide un valor entero positivo, valida que sea un numero y que sea
     * positivo
     *
     * @return numero entero byte positivo introducido por el usuario
     */
    public long pedirLongPositivo() {

        long num;
        do {
            try {
                System.out.println("Introduce un numero entero positivo long");
                num = sc.nextLong();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno negativo
                num = -1;
                sc.next();
            }

            if (num < 0) {
                System.out.println("Error, introducce un numero entero positivo long");
            }

        } while (num < 0);

        return num;
    }

    /**
     * Pide un valor entero positivo, valida que sea un numero y que sea
     * positivo
     *
     * @param mensaje
     * @return numero entero byte positivo introducido por el usuario
     */
    public long pedirLongPositivo(String mensaje) {

        long num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextLong();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno negativo
                num = -1;
                sc.next();
            }

            if (num < 0) {
                System.out.println("Error, introducce un numero entero positivo long");
            }

        } while (num < 0);

        return num;
    }

    /**
     * Pide un valor entero positivo, valida que sea un numero y que sea
     * positivo
     *
     * @param mensaje
     * @param mensajeError
     * @return numero entero byte positivo introducido por el usuario
     */
    public long pedirLongPositivo(String mensaje, String mensajeError) {

        long num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextLong();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno negativo
                num = -1;
                sc.next();
            }

            if (num < 0) {
                System.out.println(mensajeError);
            }

        } while (num < 0);

        return num;
    }

    /**
     * Pide un numero entero negativo, valida que sea un numero y sea negativo
     *
     * @return numero entero byte negativo introducido por el usuario
     */
    public long pedirLongNegativo() {
        long num;
        do {
            try {
                System.out.println("Introduce un numero entero negativo long");
                num = sc.nextLong();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno positivo
                num = 1;
                sc.next();
            }

            if (num >= 0) {
                System.out.println("Error, introducce un numero entero negativo long");
            }

        } while (num >= 0);

        return num;
    }

    /**
     * Pide un numero entero negativo, valida que sea un numero y sea negativo
     *
     * @param mensaje
     * @return numero entero byte negativo introducido por el usuario
     */
    public long pedirLongNegativo(String mensaje) {
        long num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextLong();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno positivo
                num = 1;
                sc.next();
            }

            if (num >= 0) {
                System.out.println("Error, introducce un numero entero negativo long");
            }

        } while (num >= 0);

        return num;
    }

    /**
     * Pide un numero entero negativo, valida que sea un numero y sea negativo
     *
     * @param mensaje
     * @param mensajeError
     * @return numero entero byte negativo introducido por el usuario
     */
    public long pedirLongNegativo(String mensaje, String mensajeError) {
        long num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextLong();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno positivo
                num = 1;
                sc.next();
            }

            if (num >= 0) {
                System.out.println(mensajeError);
            }

        } while (num >= 0);

        return num;
    }

    /**
     * Pide un numero entre dos numeros que le pasamos
     *
     * @param minimo
     * @param maximo
     * @return numero entero byte introducido por el usuario
     */
    public long pedirLongRango(long minimo, long maximo) {
        long num;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            long aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println("Introduce un numero long entre " + minimo + " y " + maximo);
                num = sc.nextLong();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como un numero no valido
                num = (byte) (maximo + 1);
                sc.next();
            }

            if (!(num >= minimo && num <= maximo)) {
                System.out.println("Error, Introduce un numero long entre " + minimo + " y " + maximo);
            }

        } while (!(num >= minimo && num <= maximo));

        return num;
    }

    /**
     * Pide un numero entre dos numeros que le pasamos
     *
     * @param minimo
     * @param maximo
     * @param mensaje
     * @return numero entero byte introducido por el usuario
     */
    public long pedirLongRango(long minimo, long maximo, String mensaje) {
        long num;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            long aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println(mensaje);
                num = sc.nextLong();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como un numero no valido
                num = (byte) (maximo + 1);
                sc.next();
            }

            if (!(num >= minimo && num <= maximo)) {
                System.out.println("Error, Introduce un numero long entre " + minimo + " y " + maximo);
            }

        } while (!(num >= minimo && num <= maximo));

        return num;
    }

    /**
     * Pide un numero entre dos numeros que le pasamos
     *
     * @param minimo
     * @param maximo
     * @param mensaje
     * @param mensajeError
     * @return numero entero byte introducido por el usuario
     */
    public long pedirLongRango(long minimo, long maximo, String mensaje, String mensajeError) {
        long num;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            long aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println(mensaje);
                num = sc.nextLong();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como un numero no valido
                num = (byte) (maximo + 1);
                sc.next();
            }

            if (!(num >= minimo && num <= maximo)) {
                System.out.println(mensajeError);
            }

        } while (!(num >= minimo && num <= maximo));

        return num;
    }

    /**
     * Nos pide un valor númerico, valida si es un valor numerico
     *
     * @return numero entero introducido por el usuario
     */
    public short pedirShort() {

        short num = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println("Introduce un numero entero short");
                num = sc.nextShort();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            //En caso de error, muestro el error
            if (!correcto) {
                System.out.println("Error, introducce un numero entero short");
            }

        } while (!correcto);

        return num;
    }

    /**
     * Nos pide un valor númerico, valida si es un valor numerico
     *
     * @param mensaje
     * @return numero entero introducido por el usuario
     */
    public short pedirShort(String mensaje) {

        short num = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                num = sc.nextShort();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            //En caso de error, muestro el error
            if (!correcto) {
                System.out.println("Error, introducce un numero entero short");
            }

        } while (!correcto);

        return num;
    }

    /**
     * Nos pide un valor númerico, valida si es un valor numerico
     *
     * @param mensaje
     * @param mensajeError
     * @return numero entero introducido por el usuario
     */
    public short pedirShort(String mensaje, String mensajeError) {

        short num = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                num = sc.nextShort();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            //En caso de error, muestro el error
            if (!correcto) {
                System.out.println(mensajeError);
            }

        } while (!correcto);

        return num;
    }

    /**
     * Pide un valor entero positivo, valida que sea un numero y que sea
     * positivo
     *
     * @return numero entero byte positivo introducido por el usuario
     */
    public short pedirShortPositivo() {

        short num;
        do {
            try {
                System.out.println("Introduce un numero entero positivo short");
                num = sc.nextShort();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno negativo
                num = -1;
                sc.next();
            }

            if (num < 0) {
                System.out.println("Error, introducce un numero entero positivo short");
            }

        } while (num < 0);

        return num;
    }

    /**
     * Pide un valor entero positivo, valida que sea un numero y que sea
     * positivo
     *
     * @param mensaje
     * @return numero entero byte positivo introducido por el usuario
     */
    public short pedirShortPositivo(String mensaje) {

        short num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextShort();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno negativo
                num = -1;
                sc.next();
            }

            if (num < 0) {
                System.out.println("Error, introducce un numero entero positivo short");
            }

        } while (num < 0);

        return num;
    }

    /**
     * Pide un valor entero positivo, valida que sea un numero y que sea
     * positivo
     *
     * @param mensaje
     * @param mensajeError
     * @return numero entero byte positivo introducido por el usuario
     */
    public short pedirShortPositivo(String mensaje, String mensajeError) {

        short num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextShort();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno negativo
                num = -1;
                sc.next();
            }

            if (num < 0) {
                System.out.println(mensajeError);
            }

        } while (num < 0);

        return num;
    }

    /**
     * Pide un numero entero negativo, valida que sea un numero y sea negativo
     *
     * @return numero entero byte negativo introducido por el usuario
     */
    public short pedirShortNegativo() {
        short num;
        do {
            try {
                System.out.println("Introduce un numero entero negativo short");
                num = sc.nextShort();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno positivo
                num = 1;
                sc.next();
            }

            if (num >= 0) {
                System.out.println("Error, introducce un numero entero negativo short");
            }

        } while (num >= 0);

        return num;
    }

    /**
     * Pide un numero entero negativo, valida que sea un numero y sea negativo
     *
     * @param mensaje
     * @return numero entero byte negativo introducido por el usuario
     */
    public short pedirShortNegativo(String mensaje) {
        short num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextShort();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno positivo
                num = 1;
                sc.next();
            }

            if (num >= 0) {
                System.out.println("Error, introducce un numero entero negativo short");
            }

        } while (num >= 0);

        return num;
    }

    /**
     * Pide un numero entero negativo, valida que sea un numero y sea negativo
     *
     * @param mensaje
     * @param mensajeError
     * @return numero entero byte negativo introducido por el usuario
     */
    public short pedirShortNegativo(String mensaje, String mensajeError) {
        short num;
        do {
            try {
                System.out.println(mensaje);
                num = sc.nextShort();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como uno positivo
                num = 1;
                sc.next();
            }

            if (num >= 0) {
                System.out.println(mensajeError);
            }

        } while (num >= 0);

        return num;
    }

    /**
     * Pide un numero entre dos numeros que le pasamos
     *
     * @param minimo
     * @param maximo
     * @return numero entero byte introducido por el usuario
     */
    public short pedirShortRango(long minimo, long maximo) {
        short num;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            long aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println("Introduce un numero short entre " + minimo + " y " + maximo);
                num = sc.nextShort();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como un numero no valido
                num = (byte) (maximo + 1);
                sc.next();
            }

            if (!(num >= minimo && num <= maximo)) {
                System.out.println("Error, Introduce un numero short entre " + minimo + " y " + maximo);
            }

        } while (!(num >= minimo && num <= maximo));

        return num;
    }

    /**
     * Pide un numero entre dos numeros que le pasamos
     *
     * @param minimo
     * @param maximo
     * @param mensaje
     * @return numero entero byte introducido por el usuario
     */
    public short pedirShortRango(short minimo, short maximo, String mensaje) {
        short num;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            short aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println(mensaje);
                num = sc.nextShort();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como un numero no valido
                num = (byte) (maximo + 1);
                sc.next();
            }

            if (!(num >= minimo && num <= maximo)) {
                System.out.println("Error, Introduce un numero short entre " + minimo + " y " + maximo);
            }

        } while (!(num >= minimo && num <= maximo));

        return num;
    }

    /**
     * Pide un numero entre dos numeros que le pasamos
     *
     * @param minimo
     * @param maximo
     * @param mensaje
     * @param mensajeError
     * @return numero entero byte introducido por el usuario
     */
    public short pedirShortRango(short minimo, short maximo, String mensaje, String mensajeError) {
        short num;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            short aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println(mensaje);
                num = sc.nextShort();
            } catch (InputMismatchException ex) {
                // En caso de error, el num se marca como un numero no valido
                num = (byte) (maximo + 1);
                sc.next();
            }

            if (!(num >= minimo && num <= maximo)) {
                System.out.println(mensajeError);
            }

        } while (!(num >= minimo && num <= maximo));

        return num;
    }

    /**
     * Pide un double, valida que sea un numero
     *
     * @return double introducido por el usuario
     */
    public double pedirDouble() {

        double real = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println("Introduce un numero real double");
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            if (!correcto) {
                System.out.println("Error, introduce un numero real double");
            }

        } while (!correcto);

        return real;

    }

    /**
     * Pide un double, valida que sea un numero
     *
     * @param mensaje
     * @return double introducido por el usuario
     */
    public double pedirDouble(String mensaje) {

        double real = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            if (!correcto) {
                System.out.println("Error, introduce un numero real");
            }

        } while (!correcto);

        return real;

    }

    /**
     * Pide un double, valida que sea un numero
     *
     * @param mensaje
     * @param mensajeError
     * @return double introducido por el usuario
     */
    public double pedirDouble(String mensaje, String mensajeError) {

        double real = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            if (!correcto) {
                System.out.println(mensajeError);
            }

        } while (!correcto);

        return real;

    }

    /**
     * Pide un double positivo, valida que sea un numero y positivo
     *
     * @return double positivo introducido por el usuario
     */
    public double pedirDoublePositivo() {

        double real;
        do {
            try {
                System.out.println("Introduce un numero real positivo double");
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                real = -1;
                sc.next();
            }

            if (real < 0) {
                System.out.println("Error, introducce un numero real positivo double");
            }

        } while (real < 0);

        return real;
    }

    /**
     * Pide un double positivo, valida que sea un numero y positivo
     *
     * @param mensaje
     * @return double positivo introducido por el usuario
     */
    public double pedirDoublePositivo(String mensaje) {

        double real;
        do {
            try {
                System.out.println(mensaje);
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                real = -1;
                sc.next();
            }

            if (real < 0) {
                System.out.println("Error, introducce un numero real positivo double");
            }

        } while (real < 0);

        return real;
    }

    /**
     * Pide un double positivo, valida que sea un numero y positivo
     *
     * @param mensaje
     * @param mensajeError
     * @return double positivo introducido por el usuario
     */
    public double pedirDoublePositivo(String mensaje, String mensajeError) {

        double real;
        do {
            try {
                System.out.println(mensaje);
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                real = -1;
                sc.next();
            }

            if (real < 0) {
                System.out.println(mensajeError);
            }

        } while (real < 0);

        return real;
    }

    /**
     * Pide un double negativo, valida que sea un numero y negativo
     *
     * @return double negativo introducido por el usuario
     */
    public double pedirDoubleNegativo() {
        double real;
        do {
            try {
                System.out.println("Introduce un numero real negativo double");
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                real = 1;
                sc.next();
            }

            if (real >= 0) {
                System.out.println("Error, introducce un numero real negativo double");
            }

        } while (real >= 0);

        return real;
    }

    /**
     * Pide un double negativo, valida que sea un numero y negativo
     *
     * @param mensaje
     * @return double negativo introducido por el usuario
     */
    public double pedirDoubleNegativo(String mensaje) {
        double real;
        do {
            try {
                System.out.println(mensaje);
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                real = 1;
                sc.next();
            }

            if (real >= 0) {
                System.out.println("Error, introducce un numero real negativo double");
            }

        } while (real >= 0);

        return real;
    }

    /**
     * Pide un double negativo, valida que sea un numero y negativo
     *
     * @param mensaje
     * @param mensajeError
     * @return double negativo introducido por el usuario
     */
    public double pedirDoubleNegativo(String mensaje, String mensajeError) {
        double real;
        do {
            try {
                System.out.println(mensaje);
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                real = 1;
                sc.next();
            }

            if (real >= 0) {
                System.out.println(mensajeError);
            }

        } while (real >= 0);

        return real;
    }

    /**
     * Pide un double entre en un rango, valida que sea un numero
     *
     * @param minimo
     * @param maximo
     * @return double entre un rango introducido por el usuario
     */
    public double pedirDoubleRango(double minimo, double maximo) {

        double real;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            double aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println("Introduce un numero double entre " + minimo + " y " + maximo);
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                real = maximo + 1;
                sc.next();
            }

            if (!(real >= minimo && real <= maximo)) {
                System.out.println("Error, Introduce un numero double entre " + minimo + " y " + maximo + " como maximo");
            }

        } while (!(real >= minimo && real <= maximo));

        return real;
    }

    /**
     * Pide un double entre en un rango, valida que sea un numero
     *
     * @param minimo
     * @param maximo
     * @param mensaje
     * @return double entre un rango introducido por el usuario
     */
    public double pedirDoubleRango(double minimo, double maximo, String mensaje) {

        double real;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            double aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println(mensaje);
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                real = maximo + 1;
                sc.next();
            }

            if (!(real >= minimo && real <= maximo)) {
                System.out.println("Error, Introduce un numero double entre " + minimo + " y " + maximo + " como maximo");
            }

        } while (!(real >= minimo && real <= maximo));

        return real;
    }

    /**
     * Pide un double entre en un rango, valida que sea un numero
     *
     * @param minimo
     * @param maximo
     * @param mensaje
     * @param mensajeError
     * @return double entre un rango introducido por el usuario
     */
    public double pedirDoubleRango(double minimo, double maximo, String mensaje, String mensajeError) {

        double real;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            double aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println(mensaje);
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                real = maximo + 1;
                sc.next();
            }

            if (!(real >= minimo && real <= maximo)) {
                System.out.println(mensajeError);
            }

        } while (!(real >= minimo && real <= maximo));

        return real;
    }

    /**
     * Pide un double, con un numero de decimales como maximo
     *
     * @param decimales
     * @return double con un double con unos decimales menos que lo indicado
     */
    public double pedirDoubleDecimales(int decimales) {

        if (decimales < 1) {
            decimales = 1;
        }

        double real = 0;
        boolean correcto;
        String[] parteDecimal;
        do {
            correcto = true;
            try {
                System.out.println("Introduce un numero real double con "+decimales+" decimales como maximo");
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                correcto = false;
                sc.next();
            }

            if (!correcto) {
                System.out.println("Error, introduce un numero real double");
            } else {
                parteDecimal = String.valueOf(real).split("\\.");

                if (parteDecimal[1].length() > decimales) {
                    correcto = false;
                    System.out.println("Error, el numero de decimales debe ser " + decimales + " como maximo");
                }
            }

        } while (!correcto);

        return real;

    }

    /**
     * Pide un double, con un numero de decimales como maximo
     *
     * @param decimales
     * @param mensaje
     * @return double con un double con unos decimales menos que lo indicado
     */
    public double pedirDoubleDecimales(int decimales, String mensaje) {

        if (decimales < 1) {
            decimales = 1;
        }

        double real = 0;
        boolean correcto;
        String[] parteDecimal;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                correcto = false;
                sc.next();
            }

            if (!correcto) {
                System.out.println("Error, introduce un numero real double");
            } else {
                parteDecimal = String.valueOf(real).split("\\.");

                if (parteDecimal[1].length() > decimales) {
                    correcto = false;
                    System.out.println("Error, el numero de decimales debe ser " + decimales + " como maximo");
                }
            }

        } while (!correcto);

        return real;

    }

    /**
     * Pide un double, con un numero de decimales como maximo
     *
     * @param decimales
     * @param mensaje
     * @param mensajeError
     * @return double con un double con unos decimales menos que lo indicado
     */
    public double pedirDoubleDecimales(int decimales, String mensaje, String mensajeError) {

        if (decimales < 1) {
            decimales = 1;
        }

        double real = 0;
        boolean correcto;
        String[] parteDecimal;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                correcto = false;
                sc.next();
            }

            if (!correcto) {
                System.out.println(mensajeError);
            } else {
                parteDecimal = String.valueOf(real).split("\\.");

                if (parteDecimal[1].length() > decimales) {
                    correcto = false;
                    System.out.println("Error, el numero de decimales debe ser " + decimales + " como maximo");
                }
            }

        } while (!correcto);

        return real;

    }

    /**
     * Pide un double positivo, con un numero de decimales como maximo
     *
     * @param decimales
     * @return double con un double positivo con unos decimales menos que lo
     * indicado
     */
    public double pedirDoublePositivoDecimales(int decimales) {

        double real;
        String[] parteDecimal;
        do {
            try {
                System.out.println("Introduce un numero real positivo double con "+decimales+" decimales como maximo");
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                real = -1;
                sc.next();
            }

            if (real < 0) {
                System.out.println("Error, introducce un numero real positivo double");
            } else {
                parteDecimal = String.valueOf(real).split("\\.");

                if (parteDecimal[1].length() > decimales) {
                    real = -1;
                    System.out.println("Error, el numero de decimales debe ser " + decimales);
                }
            }

        } while (real < 0);

        return real;
    }

    /**
     * Pide un double positivo, con un numero de decimales como maximo
     *
     * @param decimales
     * @param mensaje
     * @return double con un double positivo con unos decimales menos que lo
     * indicado
     */
    public double pedirDoublePositivoDecimales(int decimales, String mensaje) {

        double real;
        String[] parteDecimal;
        do {
            try {
                System.out.println(mensaje);
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                real = -1;
                sc.next();
            }

            if (real < 0) {
                System.out.println("Error, introducce un numero real positivo double");
            } else {
                parteDecimal = String.valueOf(real).split("\\.");

                if (parteDecimal[1].length() > decimales) {
                    real = -1;
                    System.out.println("Error, el numero de decimales debe ser " + decimales);
                }
            }

        } while (real < 0);

        return real;
    }

    /**
     * Pide un double positivo, con un numero de decimales como maximo
     *
     * @param decimales
     * @param mensaje
     * @param mensajeError
     * @return double con un double positivo con unos decimales menos que lo
     * indicado
     */
    public double pedirDoublePositivoDecimales(int decimales, String mensaje, String mensajeError) {

        double real;
        String[] parteDecimal;
        do {
            try {
                System.out.println(mensaje);
                real = sc.nextDouble();
            } catch (InputMismatchException ex) {
                real = -1;
                sc.next();
            }

            if (real < 0) {
                System.out.println(mensajeError);
            } else {
                parteDecimal = String.valueOf(real).split("\\.");

                if (parteDecimal[1].length() > decimales) {
                    real = -1;
                    System.out.println("Error, el numero de decimales debe ser " + decimales);
                }
            }

        } while (real < 0);

        return real;
    }

    /**
     * Pide un float, valida que sea un numero
     *
     * @return float introducido por el usuario
     */
    public float pedirFloat() {

        float real = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println("Introduce un numero real float");
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            if (!correcto) {
                System.out.println("Error, introduce un numero real float");
            }

        } while (!correcto);

        return real;

    }

    /**
     * Pide un float, valida que sea un numero
     *
     * @param mensaje
     * @return float introducido por el usuario
     */
    public float pedirFloat(String mensaje) {

        float real = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            if (!correcto) {
                System.out.println("Error, introduce un numero real float");
            }

        } while (!correcto);

        return real;

    }

    /**
     * Pide un float, valida que sea un numero
     *
     * @param mensaje
     * @param mensajeError
     * @return float introducido por el usuario
     */
    public float pedirFloat(String mensaje, String mensajeError) {

        float real = 0;
        boolean correcto;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                // En caso de error, se marca como incorrecto
                correcto = false;
                sc.next();
            }

            if (!correcto) {
                System.out.println(mensajeError);
            }

        } while (!correcto);

        return real;

    }

    /**
     * Pide un float positivo, valida que sea un numero y positivo
     *
     * @return float positivo introducido por el usuario
     */
    public float pedirFloatPositivo() {

        float real;
        do {
            try {
                System.out.println("Introduce un numero real positivo float");
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                real = -1;
                sc.next();
            }

            if (real < 0) {
                System.out.println("Error, introducce un numero real positivo float");
            }

        } while (real < 0);

        return real;
    }

    /**
     * Pide un float positivo, valida que sea un numero y positivo
     *
     * @param mensaje
     * @return float positivo introducido por el usuario
     */
    public float pedirFloatPositivo(String mensaje) {

        float real;
        do {
            try {
                System.out.println(mensaje);
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                real = -1;
                sc.next();
            }

            if (real < 0) {
                System.out.println("Error, introducce un numero real positivo float");
            }

        } while (real < 0);

        return real;
    }

    /**
     * Pide un float positivo, valida que sea un numero y positivo
     *
     * @param mensaje
     * @param mensajeError
     * @return float positivo introducido por el usuario
     */
    public float pedirFloatPositivo(String mensaje, String mensajeError) {

        float real;
        do {
            try {
                System.out.println(mensaje);
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                real = -1;
                sc.next();
            }

            if (real < 0) {
                System.out.println(mensajeError);
            }

        } while (real < 0);

        return real;
    }

    /**
     * Pide un float negativo, valida que sea un numero y negativo
     *
     * @return float negativo introducido por el usuario
     */
    public float pedirFloatNegativo() {
        float real;
        do {
            try {
                System.out.println("Introduce un numero real negativo float");
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                real = 1;
                sc.next();
            }

            if (real >= 0) {
                System.out.println("Error, introducce un numero real negativo float");
            }

        } while (real >= 0);

        return real;
    }

    /**
     * Pide un float negativo, valida que sea un numero y negativo
     *
     * @param mensaje
     * @return float negativo introducido por el usuario
     */
    public float pedirFloatNegativo(String mensaje) {
        float real;
        do {
            try {
                System.out.println(mensaje);
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                real = 1;
                sc.next();
            }

            if (real >= 0) {
                System.out.println("Error, introducce un numero real negativo float");
            }

        } while (real >= 0);

        return real;
    }

    /**
     * Pide un float negativo, valida que sea un numero y negativo
     *
     * @param mensaje
     * @param mensajeError
     * @return float negativo introducido por el usuario
     */
    public float pedirFloatNegativo(String mensaje, String mensajeError) {
        float real;
        do {
            try {
                System.out.println(mensaje);
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                real = 1;
                sc.next();
            }

            if (real >= 0) {
                System.out.println(mensajeError);
            }

        } while (real >= 0);

        return real;
    }

    /**
     * Pide un float entre en un rango, valida que sea un numero
     *
     * @param minimo
     * @param maximo
     * @return float entre un rango introducido por el usuario
     */
    public float pedirFloatRango(float minimo, float maximo) {

        float real;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            float aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println("Introduce un numero float entre " + minimo + " y " + maximo);
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                real = maximo + 1;
                sc.next();
            }

            if (!(real >= minimo && real <= maximo)) {
                System.out.println("Error, Introduce un numero float entre " + minimo + " y " + maximo + " como maximo");
            }

        } while (!(real >= minimo && real <= maximo));

        return real;
    }

    /**
     * Pide un float entre en un rango, valida que sea un numero
     *
     * @param minimo
     * @param maximo
     * @param mensaje
     * @return float entre un rango introducido por el usuario
     */
    public float pedirFloatRango(float minimo, float maximo, String mensaje) {

        float real;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            float aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println(mensaje);
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                real = maximo + 1;
                sc.next();
            }

            if (!(real >= minimo && real <= maximo)) {
                System.out.println("Error, Introduce un numero float entre " + minimo + " y " + maximo + " como maximo");
            }

        } while (!(real >= minimo && real <= maximo));

        return real;
    }

    /**
     * Pide un float entre en un rango, valida que sea un numero
     *
     * @param minimo
     * @param maximo
     * @param mensaje
     * @param mensajeError
     * @return float entre un rango introducido por el usuario
     */
    public float pedirFloatRango(float minimo, float maximo, String mensaje, String mensajeError) {

        float real;

        //En caso de el minimo sea mas grande, se intercambia
        if (minimo > maximo) {
            float aux = minimo;
            minimo = maximo;
            maximo = aux;
        }

        do {
            try {
                System.out.println(mensaje);
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                real = maximo + 1;
                sc.next();
            }

            if (!(real >= minimo && real <= maximo)) {
                System.out.println(mensajeError);
            }

        } while (!(real >= minimo && real <= maximo));

        return real;
    }
    
    /**
     * Pide un float, con un numero de decimales como maximo
     *
     * @param decimales
     * @return  float con unos decimales menos que lo indicado
     */
    public float pedirFloatDecimales(int decimales) {

        if (decimales < 1) {
            decimales = 1;
        }

        float real = 0;
        boolean correcto;
        String[] parteDecimal;
        do {
            correcto = true;
            try {
                System.out.println("Introduce un numero real float con "+decimales+" decimales como maximo");
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                correcto = false;
                sc.next();
            }

            if (!correcto) {
                System.out.println("Error, introduce un numero real float");
            } else {
                parteDecimal = String.valueOf(real).split("\\.");

                if (parteDecimal[1].length() > decimales) {
                    correcto = false;
                    System.out.println("Error, el numero de decimales debe ser " + decimales + " como maximo");
                }
            }

        } while (!correcto);

        return real;

    }

    /**
     * Pide un float, con un numero de decimales como maximo
     *
     * @param decimales
     * @param mensaje
     * @return  float con unos decimales menos que lo indicado
     */
    public float pedirFloatDecimales(int decimales, String mensaje) {

        if (decimales < 1) {
            decimales = 1;
        }

        float real = 0;
        boolean correcto;
        String[] parteDecimal;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                correcto = false;
                sc.next();
            }

            if (!correcto) {
                System.out.println("Error, introduce un numero real float con "+decimales+" decimales como maximo");
            } else {
                parteDecimal = String.valueOf(real).split("\\.");

                if (parteDecimal[1].length() > decimales) {
                    correcto = false;
                    System.out.println("Error, el numero de decimales debe ser " + decimales + " como maximo");
                }
            }

        } while (!correcto);

        return real;

    }

    /**
     * Pide un float, con un numero de decimales como maximo
     *
     * @param decimales
     * @param mensaje
     * @param mensajeError
     * @return  float con unos decimales menos que lo indicado
     */
    public float pedirFloatDecimales(int decimales, String mensaje, String mensajeError) {

        if (decimales < 1) {
            decimales = 1;
        }

        float real = 0;
        boolean correcto;
        String[] parteDecimal;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                correcto = false;
                sc.next();
            }

            if (!correcto) {
                System.out.println(mensajeError);
            } else {
                parteDecimal = String.valueOf(real).split("\\.");

                if (parteDecimal[1].length() > decimales) {
                    correcto = false;
                    System.out.println("Error, el numero de decimales debe ser " + decimales + " como maximo");
                }
            }

        } while (!correcto);

        return real;

    }

    /**
     * Pide un float positivo, con un numero de decimales como maximo
     *
     * @param decimales
     * @return float positivo con unos decimales menos que lo
     * indicado
     */
    public float pedirFloatPositivoDecimales(int decimales) {

        float real;
        String[] parteDecimal;
        do {
            try {
                System.out.println("Introduce un numero real positivo float con "+decimales+" decimales como maximo");
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                real = -1;
                sc.next();
            }

            if (real < 0) {
                System.out.println("Error, introducce un numero real positivo float");
            } else {
                parteDecimal = String.valueOf(real).split("\\.");

                if (parteDecimal[1].length() > decimales) {
                    real = -1;
                    System.out.println("Error, el numero de decimales debe ser " + decimales);
                }
            }

        } while (real < 0);

        return real;
    }

    /**
     * Pide un float positivo, con un numero de decimales como maximo
     *
     * @param decimales
     * @param mensaje
     * @return double con un float positivo con unos decimales menos que lo
     * indicado
     */
    public float pedirFloatPositivoDecimales(int decimales, String mensaje) {

        float real;
        String[] parteDecimal;
        do {
            try {
                System.out.println(mensaje);
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                real = -1;
                sc.next();
            }

            if (real < 0) {
                System.out.println("Error, introducce un numero real positivo float");
            } else {
                parteDecimal = String.valueOf(real).split("\\.");

                if (parteDecimal[1].length() > decimales) {
                    real = -1;
                    System.out.println("Error, el numero de decimales debe ser " + decimales);
                }
            }

        } while (real < 0);

        return real;
    }

    /**
     * Pide un float positivo, con un numero de decimales como maximo
     *
     * @param decimales
     * @param mensaje
     * @param mensajeError
     * @return float positivo con unos decimales menos que lo
     * indicado
     */
    public float pedirFloatPositivoDecimales(int decimales, String mensaje, String mensajeError) {

        float real;
        String[] parteDecimal;
        do {
            try {
                System.out.println(mensaje);
                real = sc.nextFloat();
            } catch (InputMismatchException ex) {
                real = -1;
                sc.next();
            }

            if (real < 0) {
                System.out.println(mensajeError);
            } else {
                parteDecimal = String.valueOf(real).split("\\.");

                if (parteDecimal[1].length() > decimales) {
                    real = -1;
                    System.out.println("Error, el numero de decimales debe ser " + decimales);
                }
            }

        } while (real < 0);

        return real;
    }

    /**
     * Pide un char, si tiene mas de un caracter, coge el primero
     *
     * @return
     */
    public char pedirChar() {

        System.out.println("Introduce un caracter (en caso de tener mas de un caracter, se cogera el primer caracter)");
        char caracter = sc.next().charAt(0);

        return caracter;

    }

    /**
     * Pide un char, si tiene mas de un caracter, coge el primero
     *
     * @param mensaje
     * @return
     */
    public char pedirChar(String mensaje) {

        System.out.println(mensaje);
        char caracter = sc.next().charAt(0);

        return caracter;

    }

    /**
     * Pide un booleano, valida que sea un booleano
     *
     * @return booleano introducido por el usuario
     */
    public boolean pedirBoolean() {

        boolean booleano = false, correcto;
        do {
            correcto = true;
            try {
                System.out.println("Introduce un booleano (true o false)");
                booleano = sc.nextBoolean();
            } catch (Exception ex) {
                correcto = false;
                sc.next();
            }
            if (!correcto) {
                System.out.println("Error, introduce un valor booleano");
            }

        } while (!correcto);

        return booleano;
    }

    /**
     * Pide un booleano, valida que sea un booleano
     *
     * @param mensaje
     * @return booleano introducido por el usuario
     */
    public boolean pedirBoolean(String mensaje) {

        boolean booleano = false, correcto;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                booleano = sc.nextBoolean();
            } catch (Exception ex) {
                correcto = false;
                sc.next();
            }
            if (!correcto) {
                System.out.println("Error, introduce un valor booleano");
            }

        } while (!correcto);

        return booleano;
    }

    /**
     * Pide un booleano, valida que sea un booleano
     *
     * @param mensaje
     * @param mensajeError
     * @return booleano introducido por el usuario
     */
    public boolean pedirBoolean(String mensaje, String mensajeError) {

        boolean booleano = false, correcto;
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                booleano = sc.nextBoolean();
            } catch (Exception ex) {
                correcto = false;
                sc.next();
            }
            if (!correcto) {
                System.out.println(mensajeError);
            }

        } while (!correcto);

        return booleano;
    }

    /**
     * Pide al usuario un si o un no, true = si, no = false
     *
     * @return booleano introducido por el usuario
     */
    public boolean pedirBooleanSiNo() {

        boolean correcto, booleano = false;
        String respuesta = "";
        do {
            correcto = true;
            try {
                System.out.println("Introduce Si o No");
                respuesta = sc.next();
                respuesta = respuesta.toLowerCase().trim();
            } catch (Exception ex) {
                correcto = false;
                sc.next();
            }

            if (respuesta.equals("si")) {
                booleano = true;
            } else if (respuesta.equals("no")) {
                booleano = false;
            } else {
                correcto = false;
            }

            if (!(respuesta.equals("si")) || respuesta.equals("no")) {
                correcto = false;
            }

            if (!correcto) {
                System.out.println("Error, introduce un valor booleano");
            }

        } while (!correcto);

        return booleano;
    }

    /**
     * Pide al usuario un si o un no, true = si, no = false
     *
     * @param mensaje
     * @return booleano introducido por el usuario
     */
    public boolean pedirBooleanSiNo(String mensaje) {

        boolean correcto, booleano = false;
        String respuesta = "";
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                respuesta = sc.next();
                respuesta = respuesta.toLowerCase().trim();
            } catch (Exception ex) {
                correcto = false;
                sc.next();
            }

            if (respuesta.equals("si")) {
                booleano = true;
            } else if (respuesta.equals("no")) {
                booleano = false;
            } else {
                correcto = false;
            }

            if (!(respuesta.equals("si")) || respuesta.equals("no")) {
                correcto = false;
            }

            if (!correcto) {
                System.out.println("Error, introduce un valor booleano");
            }

        } while (!correcto);

        return booleano;
    }

    /**
     * Pide al usuario un si o un no, true = si, no = false
     *
     * @param mensaje
     * @param mensajeError
     * @return booleano introducido por el usuario
     */
    public boolean pedirBooleanSiNo(String mensaje, String mensajeError) {

        boolean correcto, booleano = false;
        String respuesta = "";
        do {
            correcto = true;
            try {
                System.out.println(mensaje);
                respuesta = sc.next();
                respuesta = respuesta.toLowerCase().trim();
            } catch (Exception ex) {
                correcto = false;
                sc.next();
            }

            if (respuesta.equals("si")) {
                booleano = true;
            } else if (respuesta.equals("no")) {
                booleano = false;
            } else {
                correcto = false;
            }

            if (!(respuesta.equals("si")) || respuesta.equals("no")) {
                correcto = false;
            }

            if (!correcto) {
                System.out.println(mensajeError);
            }

        } while (!correcto);

        return booleano;
    }

}

— Pregunta

import listaDinamica.ListaDinamica;

public class Pregunta {
    
    private String pregunta;
    private ListaDinamica<Respuesta> respuestas;
    private int puntos;

    public Pregunta(String pregunta, ListaDinamica<Respuesta> respuestas, int puntos) {
        this.pregunta = pregunta;
        this.respuestas = respuestas;
        this.puntos = puntos;
    }

    public String getPregunta() {
        return pregunta;
    }

    public ListaDinamica<Respuesta> getRespuestas() {
        return respuestas;
    }

    public int getPuntos() {
        return puntos;
    }

    public void mostrarPregunta(){
        
        System.out.println(pregunta);
        
        int i=0;
        while(i<respuestas.size()){
            System.out.println("\t"+(i+1)+". "+respuestas.get(i));
            i++;
        }
        
    }
    
    public boolean comprobarRespuesta(int respuesta){
        
        Respuesta r = respuestas.get(respuesta - 1);
        
        if(r!=null){
            return r.isCorrecta();
        }
        
        return false;
        
    }
    
}

— Respuesta

public class Respuesta {
    
    private String respuesta;
    private boolean correcta;

    public Respuesta(String respuesta) {
        this.respuesta = respuesta;
    }

    public String getRespuesta() {
        return respuesta;
    }

    public boolean isCorrecta() {
        return correcta;
    }

    public void setCorrecta(boolean correcta) {
        this.correcta = correcta;
    }

    @Override
    public String toString() {
        return respuesta;
    }
    
    
    
    
}

— Test

import Leer.Leer;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import listaDinamica.ListaDinamica;

public class Test {

    //atributos
    private ListaDinamica<Pregunta> preguntas;
    private int puntosTotales;
    private int preguntaActual;

    //Constructor
    public Test() {
        preguntas = new ListaDinamica<>();
        puntosTotales = 0;
        preguntaActual = 0;
    }

    //Getter
    public ListaDinamica<Pregunta> getPreguntas() {
        return preguntas;
    }

    public int getPuntosTotales() {
        return puntosTotales;
    }

    public int getPreguntaActual() {
        return preguntaActual;
    }

    public Pregunta siguientePregunta() {

        //cojo la siguiente pregunta
        Pregunta p = preguntas.get(preguntaActual);

        //si la pregunta es distinto de null, paso la siguiente
        if (p != null) {
            preguntaActual++;
        }

        return p;

    }

    public void reiniciarTest() {
        preguntaActual = 0;
        puntosTotales = 0;
    }

    public void realizarTest() {

        //si estan vacias las preguntas, no hacemos nada
        if (preguntas.isEmpty()) {
            System.out.println("No hay preguntas");
        } else {

            //Creamos un objeto leer
            Leer teclado = new Leer();

            int i = 0, respuesta;
            Pregunta p;

            //recorremos las preguntas
            while (i < preguntas.size()) {

                //Cojemos una pregunta
                p = preguntas.get(i);
                //La mostramos
                p.mostrarPregunta();

                //Pedimos una respuesta
                respuesta = teclado.pedirIntRango(1, p.getRespuestas().size(), "Introduce la respuesta");

                //Comprobamos si es correcta o no
                if (p.comprobarRespuesta(respuesta)) {
                    System.out.println("Has acertado");
                    puntosTotales += p.getPuntos();
                } else {
                    System.out.println("No has acertado");
                }

                i++;
            }

        }

        //muestro los puntos
        System.out.println("Has obtenido " + puntosTotales + " puntos");

    }

    public void cargarFichero(String fichero) throws FileNotFoundException, IOException {

        //Creo el buffer
        BufferedReader br = new BufferedReader(new FileReader(fichero));

        //variables necesarias
        String linea;
        Pregunta p;
        ListaDinamica<Respuesta> respuestas = new ListaDinamica<>();
        String texto_pregunta = "";
        int puntosPregunta = 0, opcioncorrecta = 0;
        boolean pregunta = false, respuesta = false, puntos = false;

        //leo el fichero
        while ((linea = br.readLine()) != null) {

            try {

                //si empieza por ;P; es una pregunta
                if (linea.startsWith(";P;")) {
                    texto_pregunta = linea.substring(3);
                    pregunta = true; //marco que ya tengo la pregunta
                    //si tengo la pregunta y empieza por ;R; cojo la respuesta correcta
                } else if (pregunta && linea.startsWith(";R;")) {
                    opcioncorrecta = Integer.parseInt(linea.substring(3).trim());
                    respuesta = true; //marco que ya tengo la respuesta
                    //Si la respuesta esta marcada, cojo los puntos
                } else if (respuesta) {
                    puntosPregunta = Integer.parseInt(linea.trim());
                    puntos = true; //marco los puntos
                    //Si tengo la pregunta marcada, cojo la respuesta
                    //Lo pongo el ultimo en caso de que no haya nada mas
                } else if (pregunta) {
                    respuestas.addLast(new Respuesta(linea));

                    //Si tiene mas de 4 respuestas, lanzo excepcion
                    if (respuestas.size() > 4) {
                        throw new Exception();
                    }
                }

                //Si tenemos marcado la pregunta, la respuesta, los puntos y hay entre 2 y 4 opciones
                if (pregunta && respuesta && puntos && (respuestas.size() >= 2 && respuestas.size() <= 4)) {

                    //Marcamos la respuesta correcta como la correcta
                    respuestas.get(opcioncorrecta - 1).setCorrecta(true);

                    //creo la pregunta
                    p = new Pregunta(texto_pregunta, respuestas, puntosPregunta);

                    //añado la pregunta
                    preguntas.addLast(p);

                    //reincio
                    pregunta = false;
                    respuesta = false;
                    puntos = false;
                    respuestas = new ListaDinamica<>();

                }

            } catch (Exception ex) {
                //reincio
                pregunta = false;
                respuesta = false;
                puntos = false;
                respuestas = new ListaDinamica<>();
            }

        }

        br.close();

    }

}

— Main

import java.io.IOException;


public class Ejercicio_POO_DDR_13 {

    public static void main(String[] args) {
        
        Test t=new Test();
        
        try {
            t.cargarFichero("preguntas-incorrecto.txt");
            
             t.realizarTest();
            
        } catch (IOException ex) {
            System.out.println(ex.getMessage());
        }
        
    }
    
}