Java Academy · Aula

Validando a Entrada do Usuário

Trate entradas inválidas com elegância

Validando a Entrada do Usuário é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Nunca confie na entrada

Os usuários digitam valores incorretos: letras onde deveriam estar números, espaços em branco ou valores fora do intervalo. Programas robustos validam a entrada e pedem novamente em vez de falhar.

Nesta lição, você verá padrões de validação controlada com Scanner.

Verifique antes de ler

A proteção mais simples é hasNextInt(). Leia o número inteiro somente quando ele estiver realmente disponível.

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

Repetindo até ser válido

Um laço de repetição continua perguntando até que um número inteiro válido seja fornecido. Quando o elemento estiver incorreto, descarte-o com next() e continue.

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

Verificação de intervalo

Além do tipo, muitas vezes os valores precisam estar dentro de um intervalo. Leia o número e depois verifique-o antes de aceitá-lo.

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

Try-catch durante a conversão

Uma alternativa lê uma linha inteira e depois a converte, capturando NumberFormatException para textos inválidos. Isso mantém o buffer simples.

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

Validando texto não vazio

Para entradas de texto, rejeite espaços em branco. isBlank() retorna true para strings vazias ou que contêm apenas espaços em branco.

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

Validando uma opção

Para opções de menu, confirme que o valor é uma das opções permitidas antes de agir sobre ele.

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

Um método validador reutilizável

Extraia a validação para um método, para que a lógica seja reutilizada. Aqui, um método verifica se uma idade está dentro de um intervalo razoável.

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

Combinando tipo e intervalo

Na prática, a validação geralmente combina uma verificação de tipo, uma verificação de intervalo e um laço de repetição em uma única rotina 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();
    }
}

Mensagens de erro claras

Uma boa validação também fornece comentários úteis ao usuário. Informe exatamente o que estava errado e o que é esperado, em vez de exibir uma falha genérica.

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

Estratégia de validação

Verifique o tipo com a família hasNext ou com try-catch, verifique o intervalo e se o valor está vazio, repita até obter um valor válido e sempre explique os erros com clareza.

Verificação rápida

Teste seus conhecimentos sobre validação de entradas.

Recapitulação

Você aprendeu a validar entradas de forma controlada:

Proteja a leitura com hasNextInt ou faça a conversão dentro de um try-catch
Use laços de repetição, descartando elementos inválidos com next()
Verifique os intervalos e rejeite textos vazios com isBlank
Extraia métodos validadores reutilizáveis
Forneça mensagens de erro claras e específicas

Perguntas Frequentes

A aula “Validando a Entrada do Usuário” é grátis?

Sim — o texto completo de “Validando a Entrada do Usuário” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Validando a Entrada do Usuário”?

Trate entradas inválidas com elegância Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Validando a Entrada do Usuário”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy