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.

Etiquetas

Deja un comentario

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