Cómo manejar la entrada de usuario no válida en un programa Java

Introducción

Manejar la entrada de usuario no válida es un aspecto crucial de la programación en Java que garantiza que tus aplicaciones sigan siendo robustas y confiables. Cuando los usuarios interactúan con tus programas, pueden proporcionar datos inesperados o incorrectos que podrían hacer que tu aplicación se bloquee si no se gestionan adecuadamente.

En este laboratorio (lab), aprenderás cómo manejar de manera efectiva la entrada de usuario no válida en aplicaciones Java. Explorarás diferentes técnicas, desde la verificación básica de errores hasta métodos de validación más avanzados. Al final de este laboratorio (lab), serás capaz de escribir programas Java que manejen con gracia los errores de los usuarios y proporcionen una retroalimentación adecuada.

Creación de un programa básico de Java con entrada de usuario

En este primer paso, crearemos un simple programa de Java que recopile la entrada del usuario. Esto servirá como base para aprender técnicas de validación de entrada.

Comprender la entrada de usuario en Java

Java proporciona varias formas de recopilar la entrada de los usuarios. Para las aplicaciones de consola, se utiliza comúnmente la clase Scanner del paquete java.util. Esta clase ofrece métodos para leer diferentes tipos de entrada, como enteros, números de punto flotante y cadenas.

Creación del programa de entrada

Comencemos creando un programa básico de Java que solicite la edad de un usuario y la imprima.

Primero, abre el WebIDE y navega hasta el directorio del proyecto:
Crea un nuevo archivo haciendo clic en el icono "Nuevo archivo" en el explorador de archivos del WebIDE. Nombrar el archivo UserInputDemo.java
Agrega el siguiente código al archivo:

import java.util.Scanner;

public class UserInputDemo {
    public static void main(String[] args) {
        // Create a Scanner object to read input
        Scanner scanner = new Scanner(System.in);

        // Prompt the user for their age
        System.out.print("Please enter your age: ");

        // Read the input
        int age = scanner.nextInt();

        // Display the entered age
        System.out.println("You entered: " + age);

        // Close the scanner
        scanner.close();
    }
}

Guarda el archivo presionando Ctrl+S o seleccionando "Archivo" > "Guardar" desde el menú.
Abre una terminal en el WebIDE haciendo clic en "Terminal" > "Nueva terminal" desde el menú superior.

Input Demo

Compila el programa de Java ejecutando el siguiente comando:

javac UserInputDemo.java

Ejecuta el programa con:

java UserInputDemo

Ingresa un número cuando se te solicite, por ejemplo, 25. Deberías ver la siguiente salida:

Please enter your age: 25
You entered: 25

¿Qué sucede con la entrada no válida?

Ahora, veamos qué sucede cuando proporcionamos una entrada no válida. Vuelve a ejecutar el programa:

java UserInputDemo

Esta vez, ingresa un valor no numérico, como twenty-five. Verás un mensaje de error similar a:

Please enter your age: twenty-five
Exception in thread "main" java.util.InputMismatchException
 at java.base/java.util.Scanner.throwFor(Scanner.java:943)
 at java.base/java.util.Scanner.next(Scanner.java:1598)
 at java.base/java.util.Scanner.nextInt(Scanner.java:2263)
 at java.base/java.util.Scanner.nextInt(Scanner.java:2217)
 at UserInputDemo.main(UserInputDemo.java:12)

Esta InputMismatchException se produce porque el programa esperaba una entrada numérica (un entero), pero recibió texto en su lugar. El programa se bloquea en lugar de manejar esto con gracia. En los siguientes pasos, aprenderemos cómo manejar adecuadamente este tipo de entradas no válidas.

Manejo de excepciones para entrada no válida

En este paso, modificaremos nuestro programa para manejar la entrada no válida utilizando el mecanismo de manejo de excepciones de Java.

Comprender las excepciones de Java

Las excepciones en Java son eventos que interrumpen el flujo normal de ejecución del programa. Cuando un usuario proporciona una entrada no válida, el sistema de tiempo de ejecución de Java lanza una excepción para indicar que algo salió mal. El programa puede capturar estas excepciones y manejarlas adecuadamente, en lugar de fallar.

La estructura básica para el manejo de excepciones en Java es el bloque try-catch:

try {
    // Code that might throw an exception
} catch (ExceptionType e) {
    // Code to handle the exception
}

Modificar nuestro programa para manejar excepciones

Actualicemos nuestro programa para manejar la InputMismatchException que se produce cuando el usuario ingresa una entrada no numérica:

Abre el archivo UserInputDemo.java en el WebIDE.
Modifica el código para incluir el manejo de excepciones:

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

public class UserInputDemo {
    public static void main(String[] args) {
        // Create a Scanner object to read input
        Scanner scanner = new Scanner(System.in);

        try {
            // Prompt the user for their age
            System.out.print("Please enter your age: ");

            // Read the input
            int age = scanner.nextInt();

            // Display the entered age
            System.out.println("You entered: " + age);
        } catch (InputMismatchException e) {
            // Handle the exception if non-numeric input is provided
            System.out.println("Error: Please enter a valid numeric age.");
        } finally {
            // Close the scanner in the finally block to ensure it always gets closed
            scanner.close();
        }
    }
}

Guarda el archivo presionando Ctrl+S.
Compila el programa actualizado:

javac UserInputDemo.java

Ejecuta el programa:

java UserInputDemo

Intenta ingresar un valor no numérico, como twenty-five. En lugar de fallar, el programa ahora muestra:

Please enter your age: twenty-five
Error: Please enter a valid numeric age.

Mejorar nuestro manejo de excepciones

Nuestra implementación actual maneja la excepción, pero sale inmediatamente. Mejorémosla dando al usuario múltiples intentos para ingresar una edad válida:

Abre el archivo UserInputDemo.java en el WebIDE.
Modifica el código para permitir múltiples intentos:

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

public class UserInputDemo {
    public static void main(String[] args) {
        // Create a Scanner object to read input
        Scanner scanner = new Scanner(System.in);

        boolean validInput = false;
        int age = 0;

        // Keep trying until valid input is received
        while (!validInput) {
            try {
                // Prompt the user for their age
                System.out.print("Please enter your age: ");

                // Read the input
                age = scanner.nextInt();

                // If we get here, the input was valid
                validInput = true;
            } catch (InputMismatchException e) {
                // Handle the exception if non-numeric input is provided
                System.out.println("Error: Please enter a valid numeric age.");

                // Clear the invalid input from the scanner
                scanner.nextLine();
            }
        }

        // Display the entered age
        System.out.println("You entered: " + age);

        // Close the scanner
        scanner.close();
    }
}

Guarda el archivo.
Compila y ejecuta el programa nuevamente:

javac UserInputDemo.java
java UserInputDemo

Intenta ingresar primero una entrada no válida y luego una válida:

Please enter your age: twenty-five
Error: Please enter a valid numeric age.
Please enter your age: 25
You entered: 25

Ahora nuestro programa da al usuario múltiples oportunidades para proporcionar una entrada válida. Esto es una mejora significativa en el manejo de la entrada no válida de manera elegante.

Implementación de la validación de entrada con declaraciones condicionales

Además del manejo de excepciones, podemos utilizar declaraciones condicionales para validar la entrada del usuario. Este enfoque nos permite implementar reglas de validación personalizadas antes de procesar la entrada.

Comprender la validación de entrada

La validación de entrada es el proceso de verificar la entrada del usuario para asegurarse de que cumpla con criterios específicos antes de procesarla. Por ejemplo, es posible que queramos asegurarnos de que un valor de edad no solo sea un número, sino que también esté dentro de un rango razonable.

Agregar validación de rango a nuestro programa

Mejoremos nuestro programa para validar que el usuario ingrese una edad entre 0 y 120:

Abre el archivo UserInputDemo.java en el WebIDE.
Modifica el código para incluir la validación de rango:

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

public class UserInputDemo {
    public static void main(String[] args) {
        // Create a Scanner object to read input
        Scanner scanner = new Scanner(System.in);

        boolean validInput = false;
        int age = 0;

        // Keep trying until valid input is received
        while (!validInput) {
            try {
                // Prompt the user for their age
                System.out.print("Please enter your age (0-120): ");

                // Read the input
                age = scanner.nextInt();

                // Check if the age is within a valid range
                if (age < 0 || age > 120) {
                    System.out.println("Error: Age must be between 0 and 120.");
                } else {
                    // If we get here, the input was valid
                    validInput = true;
                }
            } catch (InputMismatchException e) {
                // Handle the exception if non-numeric input is provided
                System.out.println("Error: Please enter a valid numeric age.");

                // Clear the invalid input from the scanner
                scanner.nextLine();
            }
        }

        // Display the entered age
        System.out.println("You entered: " + age);

        // Close the scanner
        scanner.close();
    }
}

Guarda el archivo presionando Ctrl+S.
Compila el programa:

javac UserInputDemo.java

Ejecuta el programa:

java UserInputDemo

Prueba el programa con diferentes entradas:

Ingresa una edad válida (por ejemplo, 25):

Please enter your age (0-120): 25
You entered: 25

Ingresa una edad negativa:

Please enter your age (0-120): -5
Error: Age must be between 0 and 120.
Please enter your age (0-120):

Ingresa una edad mayor a 120:

Please enter your age (0-120): 150
Error: Age must be between 0 and 120.
Please enter your age (0-120):

Ingresa un valor no numérico:

Please enter your age (0-120): twenty-five
Error: Please enter a valid numeric age.
Please enter your age (0-120):

Crear un ejemplo más complejo: Formulario de registro de usuario

Creemos un ejemplo más completo que valide múltiples campos para un formulario de registro de usuario:

Crea un nuevo archivo llamado UserRegistration.java en el WebIDE.
Agrega el siguiente código al archivo:

import java.util.Scanner;

public class UserRegistration {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Get and validate username
        String username = getValidUsername(scanner);

        // Get and validate age
        int age = getValidAge(scanner);

        // Get and validate email
        String email = getValidEmail(scanner);

        // Display the registration information
        System.out.println("\nRegistration Successful!");
        System.out.println("Username: " + username);
        System.out.println("Age: " + age);
        System.out.println("Email: " + email);

        scanner.close();
    }

    private static String getValidUsername(Scanner scanner) {
        String username;
        boolean validUsername = false;

        do {
            System.out.print("Enter username (3-15 characters): ");
            username = scanner.nextLine().trim();

            if (username.length() < 3 || username.length() > 15) {
                System.out.println("Error: Username must be between 3 and 15 characters.");
            } else {
                validUsername = true;
            }
        } while (!validUsername);

        return username;
    }

    private static int getValidAge(Scanner scanner) {
        int age = 0;
        boolean validAge = false;

        while (!validAge) {
            try {
                System.out.print("Enter your age (0-120): ");
                age = Integer.parseInt(scanner.nextLine());

                if (age < 0 || age > 120) {
                    System.out.println("Error: Age must be between 0 and 120.");
                } else {
                    validAge = true;
                }
            } catch (NumberFormatException e) {
                System.out.println("Error: Please enter a valid numeric age.");
            }
        }

        return age;
    }

    private static String getValidEmail(Scanner scanner) {
        String email;
        boolean validEmail = false;

        do {
            System.out.print("Enter your email: ");
            email = scanner.nextLine().trim();

            // Simple email validation: must contain @ and a period after @
            if (!email.contains("@") || email.indexOf('.', email.indexOf('@')) == -1) {
                System.out.println("Error: Please enter a valid email address.");
            } else {
                validEmail = true;
            }
        } while (!validEmail);

        return email;
    }
}

Guarda el archivo presionando Ctrl+S.
Compila el programa:

javac UserRegistration.java

Ejecuta el programa:

java UserRegistration

Sigue las indicaciones para ingresar un nombre de usuario, edad y correo electrónico. El programa validará cada entrada y solo continuará cuando se ingrese datos válidos.

Secuencia de entrada válida de muestra:

Enter username (3-15 characters): johnsmith
Enter your age (0-120): 30
Enter your email: john.smith@example.com

Registration Successful!
Username: johnsmith
Age: 30
Email: john.smith@example.com

Este ejemplo más completo demuestra cómo validar diferentes tipos de entrada del usuario utilizando tanto el manejo de excepciones como la validación condicional.

Uso de expresiones regulares para la validación de entrada

Las expresiones regulares (regex) proporcionan una forma poderosa de validar patrones de entrada complejos, como direcciones de correo electrónico, números de teléfono y contraseñas. En este paso, aprenderemos cómo usar expresiones regulares en Java para realizar una validación de entrada avanzada.

Comprender las expresiones regulares

Una expresión regular es una secuencia de caracteres que define un patrón de búsqueda. Estos patrones se pueden utilizar para validar si una cadena se ajusta a un formato específico. Java proporciona el paquete java.util.regex, que incluye las clases Pattern y Matcher para trabajar con expresiones regulares.

Agregar validación de regex a nuestro programa UserRegistration

Mejoremos nuestro programa UserRegistration para usar expresiones regulares para una validación de entrada más robusta:

Abre el archivo UserRegistration.java en el WebIDE.
Modifica el archivo para incluir la validación de regex:

import java.util.Scanner;
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class UserRegistration {
    // Regular expression patterns
    private static final String USERNAME_PATTERN = "^[a-zA-Z0-9_]{3,15}$";
    private static final String EMAIL_PATTERN = "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";
    private static final String PHONE_PATTERN = "^\\d{3}-\\d{3}-\\d{4}$";

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Get and validate username
        String username = getValidUsername(scanner);

        // Get and validate age
        int age = getValidAge(scanner);

        // Get and validate email
        String email = getValidEmail(scanner);

        // Get and validate phone number
        String phone = getValidPhone(scanner);

        // Display the registration information
        System.out.println("\nRegistration Successful!");
        System.out.println("Username: " + username);
        System.out.println("Age: " + age);
        System.out.println("Email: " + email);
        System.out.println("Phone: " + phone);

        scanner.close();
    }

    private static String getValidUsername(Scanner scanner) {
        String username;
        boolean validUsername = false;
        Pattern pattern = Pattern.compile(USERNAME_PATTERN);

        do {
            System.out.print("Enter username (3-15 alphanumeric characters or underscore): ");
            username = scanner.nextLine().trim();

            Matcher matcher = pattern.matcher(username);
            if (!matcher.matches()) {
                System.out.println("Error: Username must be 3-15 characters long and contain only letters, numbers, or underscores.");
            } else {
                validUsername = true;
            }
        } while (!validUsername);

        return username;
    }

    private static int getValidAge(Scanner scanner) {
        int age = 0;
        boolean validAge = false;

        while (!validAge) {
            try {
                System.out.print("Enter your age (0-120): ");
                age = Integer.parseInt(scanner.nextLine());

                if (age < 0 || age > 120) {
                    System.out.println("Error: Age must be between 0 and 120.");
                } else {
                    validAge = true;
                }
            } catch (NumberFormatException e) {
                System.out.println("Error: Please enter a valid numeric age.");
            }
        }

        return age;
    }

    private static String getValidEmail(Scanner scanner) {
        String email;
        boolean validEmail = false;
        Pattern pattern = Pattern.compile(EMAIL_PATTERN);

        do {
            System.out.print("Enter your email: ");
            email = scanner.nextLine().trim();

            Matcher matcher = pattern.matcher(email);
            if (!matcher.matches()) {
                System.out.println("Error: Please enter a valid email address.");
            } else {
                validEmail = true;
            }
        } while (!validEmail);

        return email;
    }

    private static String getValidPhone(Scanner scanner) {
        String phone;
        boolean validPhone = false;
        Pattern pattern = Pattern.compile(PHONE_PATTERN);

        do {
            System.out.print("Enter your phone number (format: 123-456-7890): ");
            phone = scanner.nextLine().trim();

            Matcher matcher = pattern.matcher(phone);
            if (!matcher.matches()) {
                System.out.println("Error: Please enter a valid phone number in the format 123-456-7890.");
            } else {
                validPhone = true;
            }
        } while (!validPhone);

        return phone;
    }
}

Guarda el archivo presionando Ctrl+S.
Compila el programa:

javac UserRegistration.java

Ejecuta el programa:

java UserRegistration

Prueba el programa con diferentes entradas:

Intenta ingresar un nombre de usuario no válido (demasiado corto, que contenga caracteres especiales):

Enter username (3-15 alphanumeric characters or underscore): a$
Error: Username must be 3-15 characters long and contain only letters, numbers, or underscores.
Enter username (3-15 alphanumeric characters or underscore):

Intenta ingresar un correo electrónico no válido (faltando @ o dominio):

Enter username (3-15 alphanumeric characters or underscore): johndoe
Enter your age (0-120): 25
Enter your email: johndoe.com
Error: Please enter a valid email address.
Enter your email:

Intenta ingresar un número de teléfono no válido (formato incorrecto):

Enter username (3-15 alphanumeric characters or underscore): johndoe
Enter your age (0-120): 25
Enter your email: john.doe@example.com
Enter your phone number (format: 123-456-7890): 1234567890
Error: Please enter a valid phone number in the format 123-456-7890.
Enter your phone number (format: 123-456-7890):

Ingresa todas las entradas válidas:

Enter username (3-15 alphanumeric characters or underscore): johndoe
Enter your age (0-120): 25
Enter your email: john.doe@example.com
Enter your phone number (format: 123-456-7890): 123-456-7890

Registration Successful!
Username: johndoe
Age: 25
Email: john.doe@example.com
Phone: 123-456-7890

Comprender los patrones de expresiones regulares

Examinemos los patrones de expresiones regulares utilizados en nuestro programa:

USERNAME_PATTERN: ^[a-zA-Z0-9_]{3,15}$
- ^ y $ aseguran que el patrón coincida con toda la cadena
- [a-zA-Z0-9_] coincide con cualquier letra (mayúscula o minúscula), número o guion bajo
- {3,15} especifica que la longitud debe estar entre 3 y 15 caracteres
EMAIL_PATTERN: ^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$
- Este patrón valida las direcciones de correo electrónico de acuerdo con reglas comunes
- Asegura que el correo electrónico tenga una parte de nombre de usuario, un símbolo @ y un dominio
PHONE_PATTERN: ^\\d{3}-\\d{3}-\\d{4}$
- \\d coincide con cualquier dígito (0-9)
- {3} y {4} especifican el número de dígitos
- - coincide con el carácter de guion literal

Las expresiones regulares son una herramienta poderosa para la validación de entrada, pero pueden ser complejas. A medida que te sientas más cómodo con ellas, podrás crear patrones de validación más sofisticados para tus aplicaciones.

Creación de un sistema completo de validación de formularios

En este último paso, construiremos un sistema completo de validación de formularios que incorpore todas las técnicas que hemos aprendido. Crearemos un sistema de validación más modular y reutilizable que se pueda extender fácilmente para diferentes aplicaciones.

Creación de una clase de utilidad de validación

Comencemos creando una clase de utilidad que encapsule nuestros métodos de validación:

Crea un nuevo archivo llamado InputValidator.java en el WebIDE.
Agrega el siguiente código al archivo:

import java.util.regex.Pattern;
import java.util.regex.Matcher;

/**
 * Utility class for validating user input
 */
public class InputValidator {
    // Regular expression patterns
    private static final String USERNAME_PATTERN = "^[a-zA-Z0-9_]{3,15}$";
    private static final String EMAIL_PATTERN = "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";
    private static final String PHONE_PATTERN = "^\\d{3}-\\d{3}-\\d{4}$";
    private static final String PASSWORD_PATTERN = "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,}$";

    /**
     * Validates a username
     * @param username The username to validate
     * @return true if the username is valid, false otherwise
     */
    public static boolean isValidUsername(String username) {
        if (username == null) {
            return false;
        }
        Pattern pattern = Pattern.compile(USERNAME_PATTERN);
        Matcher matcher = pattern.matcher(username);
        return matcher.matches();
    }

    /**
     * Validates an email address
     * @param email The email to validate
     * @return true if the email is valid, false otherwise
     */
    public static boolean isValidEmail(String email) {
        if (email == null) {
            return false;
        }
        Pattern pattern = Pattern.compile(EMAIL_PATTERN);
        Matcher matcher = pattern.matcher(email);
        return matcher.matches();
    }

    /**
     * Validates a phone number
     * @param phone The phone number to validate
     * @return true if the phone number is valid, false otherwise
     */
    public static boolean isValidPhone(String phone) {
        if (phone == null) {
            return false;
        }
        Pattern pattern = Pattern.compile(PHONE_PATTERN);
        Matcher matcher = pattern.matcher(phone);
        return matcher.matches();
    }

    /**
     * Validates an age
     * @param age The age to validate
     * @return true if the age is valid, false otherwise
     */
    public static boolean isValidAge(int age) {
        return age >= 0 && age <= 120;
    }

    /**
     * Validates a password
     * @param password The password to validate
     * @return true if the password is valid, false otherwise
     */
    public static boolean isValidPassword(String password) {
        if (password == null) {
            return false;
        }
        Pattern pattern = Pattern.compile(PASSWORD_PATTERN);
        Matcher matcher = pattern.matcher(password);
        return matcher.matches();
    }

    /**
     * Gets the error message for an invalid username
     * @return The error message
     */
    public static String getUsernameErrorMessage() {
        return "Username must be 3-15 characters long and contain only letters, numbers, or underscores.";
    }

    /**
     * Gets the error message for an invalid email
     * @return The error message
     */
    public static String getEmailErrorMessage() {
        return "Please enter a valid email address.";
    }

    /**
     * Gets the error message for an invalid phone number
     * @return The error message
     */
    public static String getPhoneErrorMessage() {
        return "Please enter a valid phone number in the format 123-456-7890.";
    }

    /**
     * Gets the error message for an invalid age
     * @return The error message
     */
    public static String getAgeErrorMessage() {
        return "Age must be between 0 and 120.";
    }

    /**
     * Gets the error message for an invalid password
     * @return The error message
     */
    public static String getPasswordErrorMessage() {
        return "Password must be at least 8 characters long and contain at least one digit, one lowercase letter, one uppercase letter, one special character, and no whitespace.";
    }
}

Guarda el archivo presionando Ctrl+S.

Creación de un formulario de registro completo

Ahora, creemos una nueva versión de nuestro formulario de registro que utilice la clase InputValidator:

Crea un nuevo archivo llamado CompleteRegistrationForm.java en el WebIDE.
Agrega el siguiente código al archivo:

import java.util.Scanner;

public class CompleteRegistrationForm {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Collect and validate user information
        String username = getValidInput(scanner, "Username", InputValidator::isValidUsername, InputValidator.getUsernameErrorMessage());
        int age = getValidAge(scanner);
        String email = getValidInput(scanner, "Email", InputValidator::isValidEmail, InputValidator.getEmailErrorMessage());
        String phone = getValidInput(scanner, "Phone number (format: 123-456-7890)", InputValidator::isValidPhone, InputValidator.getPhoneErrorMessage());
        String password = getValidInput(scanner, "Password", InputValidator::isValidPassword, InputValidator.getPasswordErrorMessage());

        // Display the registration information
        System.out.println("\nRegistration Successful!");
        System.out.println("Username: " + username);
        System.out.println("Age: " + age);
        System.out.println("Email: " + email);
        System.out.println("Phone: " + phone);
        System.out.println("Password: " + maskPassword(password));

        scanner.close();
    }

    /**
     * Generic method to get valid input from the user
     * @param scanner The scanner to read input
     * @param fieldName The name of the field being validated
     * @param validator The validation function
     * @param errorMessage The error message to display
     * @return The validated input
     */
    private static String getValidInput(Scanner scanner, String fieldName, java.util.function.Predicate<String> validator, String errorMessage) {
        String input;
        boolean validInput = false;

        do {
            System.out.print("Enter your " + fieldName + ": ");
            input = scanner.nextLine().trim();

            if (!validator.test(input)) {
                System.out.println("Error: " + errorMessage);
            } else {
                validInput = true;
            }
        } while (!validInput);

        return input;
    }

    /**
     * Gets a valid age from the user
     * @param scanner The scanner to read input
     * @return The validated age
     */
    private static int getValidAge(Scanner scanner) {
        int age = 0;
        boolean validAge = false;

        while (!validAge) {
            try {
                System.out.print("Enter your age (0-120): ");
                age = Integer.parseInt(scanner.nextLine());

                if (!InputValidator.isValidAge(age)) {
                    System.out.println("Error: " + InputValidator.getAgeErrorMessage());
                } else {
                    validAge = true;
                }
            } catch (NumberFormatException e) {
                System.out.println("Error: Please enter a valid numeric age.");
            }
        }

        return age;
    }

    /**
     * Masks a password for display
     * @param password The password to mask
     * @return The masked password
     */
    private static String maskPassword(String password) {
        if (password == null || password.isEmpty()) {
            return "";
        }
        return "*".repeat(password.length());
    }
}

Guarda el archivo presionando Ctrl+S.
Compila ambos archivos Java:

javac InputValidator.java
javac CompleteRegistrationForm.java

Ejecuta el programa del formulario de registro:

java CompleteRegistrationForm

Sigue las indicaciones para ingresar información válida para cada campo. El programa validará cada entrada de acuerdo con las reglas definidas en la clase InputValidator.

Interacción de muestra:

Enter your Username: john_doe
Enter your age (0-120): 35
Enter your Email: john.doe@example.com
Enter your Phone number (format: 123-456-7890): 123-456-7890
Enter your Password: weakpw
Error: Password must be at least 8 characters long and contain at least one digit, one lowercase letter, one uppercase letter, one special character, and no whitespace.
Enter your Password: P@ssw0rd123

Registration Successful!
Username: john_doe
Age: 35
Email: john.doe@example.com
Phone: 123-456-7890
Password: ***********

Beneficios de este enfoque

El enfoque que hemos adoptado en este último ejemplo ofrece varias ventajas:

Modularidad: La lógica de validación se separa en una clase de utilidad reutilizable.
Extensibilidad: Se pueden agregar fácilmente nuevas reglas de validación a la clase InputValidator.
Mantenibilidad: Los mensajes de error se centralizan y se pueden actualizar fácilmente.
Reutilización de código: El método getValidInput es genérico y se puede utilizar para diferentes tipos de entrada.
Seguridad: La contraseña se enmascara cuando se muestra al usuario.

Este diseño sigue los principios de buen ingeniería de software y facilita la adaptación del sistema para diferentes aplicaciones.

Resumen

En este laboratorio, has aprendido cómo manejar de manera efectiva la entrada de usuario no válida en programas Java. Has progresado desde una comprensión básica del manejo de entrada hasta la implementación de un sistema de validación integral. Aquí está un resumen de lo que has logrado:

Creaste un programa Java básico que recopila la entrada del usuario utilizando la clase Scanner
Implementaste el manejo de excepciones para gestionar con elegancia la entrada no válida
Añadiste validación condicional para asegurar que la entrada cumpla con criterios específicos
Utilizaste expresiones regulares para una validación avanzada basada en patrones
Construiste un sistema de validación modular y reutilizable con una clase de utilidad

Estas técnicas son esenciales para desarrollar aplicaciones Java robustas que puedan manejar la naturaleza impredecible de la entrada del usuario. Al validar y manejar adecuadamente la entrada no válida, puedes prevenir fallos en el programa, mantener la integridad de los datos y brindar una mejor experiencia de usuario.

A medida que continúes tu viaje en la programación Java, recuerda que la validación de entrada no se trata solo de prevenir errores, sino también de mejorar la seguridad y la usabilidad. Los principios que has aprendido en este laboratorio se pueden aplicar a varios tipos de aplicaciones, desde programas de consola simples hasta aplicaciones web complejas.