Java Academy · Lección

Validar entradas del usuario

Gestione entradas no válidas correctamente

Validar entradas del usuario es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

No confíe nunca en la entrada

Los usuarios introducen datos incorrectos: letras donde deberían ir números, espacios en blanco o valores fuera de rango. Los programas robustos validan la entrada y vuelven a solicitarla en lugar de bloquearse.

Esta lección muestra patrones de validación segura con Scanner.

Compruebe antes de leer

La protección más sencilla es hasNextInt(). Lea el entero únicamente cuando haya uno disponible.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner("42");
        if (scanner.hasNextInt()) {
            System.out.println("Got: " + scanner.nextInt());
        } else {
            System.out.println("Please enter a number");
        }
        scanner.close();
    }
}

Repetir hasta obtener un valor válido

Un bucle de reintento sigue solicitando datos hasta que llega un entero válido. Cuando el token sea incorrecto, deséchelo con next() y continúe.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner("abc xyz 50");
        int value = -1;
        while (scanner.hasNext()) {
            if (scanner.hasNextInt()) {
                value = scanner.nextInt();
                break;
            }
            scanner.next();
        }
        System.out.println("Accepted: " + value);
        scanner.close();
    }
}

Comprobar el rango

Además del tipo, los valores suelen tener que encontrarse dentro de un rango. Lea el número y verifíquelo antes de aceptarlo.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner("7");
        int n = scanner.nextInt();
        if (n >= 1 && n <= 10) {
            System.out.println("Valid: " + n);
        } else {
            System.out.println("Out of range");
        }
        scanner.close();
    }
}

Usar try-catch al analizar

Otra opción consiste en leer una línea completa y analizarla, capturando NumberFormatException si el texto no es válido. Así el búfer se mantiene sencillo.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner("notanumber");
        String line = scanner.nextLine();
        try {
            int n = Integer.parseInt(line.trim());
            System.out.println("Parsed: " + n);
        } catch (NumberFormatException e) {
            System.out.println("Invalid number: " + line);
        }
        scanner.close();
    }
}

Validar texto no vacío

En las entradas de texto, rechace los valores en blanco. isBlank() devuelve true para las cadenas vacías o compuestas únicamente por espacios en blanco.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner("   ");
        String name = scanner.nextLine();
        if (name.isBlank()) {
            System.out.println("Name cannot be empty");
        } else {
            System.out.println("Hello, " + name);
        }
        scanner.close();
    }
}

Validar una opción

En las opciones de un menú, confirme que el valor sea una de las opciones permitidas antes de actuar en consecuencia.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner("y");
        String choice = scanner.next().toLowerCase();
        if (choice.equals("y") || choice.equals("n")) {
            System.out.println("You chose: " + choice);
        } else {
            System.out.println("Please enter y or n");
        }
        scanner.close();
    }
}

Un método validador reutilizable

Extraiga la validación a un método para reutilizar la lógica. En este caso, un método comprueba que una edad se encuentre dentro de un rango razonable.

public class Main {
    static boolean isValidAge(int age) {
        return age >= 0 && age <= 120;
    }

    public static void main(String[] args) {
        System.out.println(isValidAge(30));
        System.out.println(isValidAge(-5));
    }
}

Combinar tipo y rango

La validación real suele combinar una comprobación de tipo, una comprobación de rango y un bucle de reintento en una única rutina robusta.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner("abc 200 45");
        int valid = -1;
        while (scanner.hasNext()) {
            if (scanner.hasNextInt()) {
                int n = scanner.nextInt();
                if (n >= 1 && n <= 100) {
                    valid = n;
                    break;
                }
            } else {
                scanner.next();
            }
        }
        System.out.println("Final: " + valid);
        scanner.close();
    }
}

Mensajes de error claros

Una buena validación también proporciona al usuario información útil. Explique exactamente qué estaba mal y qué se esperaba, en lugar de mostrar un error genérico.

public class Main {
    static String validate(String input) {
        if (input.isBlank()) return "Input is empty";
        if (!input.matches("\\d+")) return "Only digits allowed";
        return "OK";
    }

    public static void main(String[] args) {
        System.out.println(validate(""));
        System.out.println(validate("12a"));
        System.out.println(validate("123"));
    }
}

Estrategia de validación

Compruebe el tipo con la familia hasNext o mediante try-catch, compruebe el rango y que el valor no esté vacío, repita hasta obtener un valor válido y explique siempre los errores con claridad.

Comprobación rápida

Compruebe sus conocimientos sobre la validación de entradas.

Resumen

Ha aprendido a validar la entrada de forma segura:

Use hasNextInt como protección o analice el valor dentro de un try-catch
Use bucles de reintento y descarte los tokens incorrectos con next()
Compruebe los rangos y rechace el texto en blanco con isBlank
Extraiga métodos validadores reutilizables
Proporcione mensajes de error claros y específicos

Preguntas frecuentes

¿La lección «Validar entradas del usuario» es gratis?

Sí — el texto completo de «Validar entradas del usuario» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Validar entradas del usuario»?

Gestione entradas no válidas correctamente Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Validar entradas del usuario»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Java Academy