Clase Leer Java

Hola a todos, hoy os dejo una clase hecha por mí, que nos ayudará a pedir valores y validarlos.

Es muy normal que en un programa, pidamos valores al usuario y tengamos que validarlos. Por ejemplo, pedir un valor numérico entre 0 y 10, además de pedirlo, tendriamos que validarlo para que en caso de que el usuario no meta un valor correcto, nos lo vuelva a pedir.

Esta clase nos permite lo siguiente:

  • Pedir valores numéricos enteros (solo enteros)
  • Pedir valores numéricos enteros positivos (valida que sea positivo, incluye el cero)
  • Pedir valores numéricos enteros negativos (valida que se sea negativo)
  • Pedir valores numéricos enteros entre un valor y otro (valida que esté en ese rango)
  • Pedir valores numéricos reales (solo reales)
  • Pedir valores numéricos reales positivos (valida que sea positivo, incluye el cero)
  • Pedir valores numéricos reales negativos (valida que se sea negativo)
  • Pedir valores numéricos reales entre un valor y otro (valida que esté en ese rango)
  • Pedir valores numéricos reales con un número máximo de decimales (para precios por ejemplo)
  • Pedir cadenas
  • Pedir cadenas con un máximo de caracteres
  • Pedir caracteres
  • Pedir booleanos

Todos ellos tienen una variación donde puedes añadir un texto personalizado de introducción de datos y otro de error.

Aquí os dejo el código para que lo uséis en vuestros proyectos.

Aquí lo puedes descargar.


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;
    }

}

¿Quieres que agreguemos alguna función más? Comentanos.

Espero que os sea de ayuda, si tenéis dudas, preguntad. Estamos para ayudarte.

¿Te ha gustado y quieres apoyarme? ¡Sé mi patrón!
Etiquetas

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *