Como Verificar se um Número é Par em Java: Guia Prático

Introdução

Neste laboratório, você aprenderá como determinar se um número é par ou ímpar em Java. Exploraremos o uso do operador módulo (%) para verificar o resto quando um número é dividido por 2, que é o princípio fundamental para identificar números pares.

Você implementará um programa Java simples para realizar essa verificação, testá-lo com entradas de inteiros positivos e negativos e considerar como lidar com entradas não inteiras para tornar sua solução mais robusta.

Usar o Operador Módulo para Verificação de Paridade

Nesta etapa, aprenderemos como determinar se um número é par ou ímpar em Java usando o operador módulo. O operador módulo (%) fornece o resto de uma divisão. Por exemplo, 10 % 3 é 1 porque 10 dividido por 3 é 3 com um resto de 1.

Um número par é qualquer inteiro que pode ser dividido por 2 sem resto. Isso significa que, se você dividir um número par por 2, o resto é sempre 0. Podemos usar o operador módulo para verificar essa condição.

Vamos criar um programa Java simples para verificar se um número é par.

Abra o arquivo EvenCheck.java no editor WebIDE. Se o arquivo não existir, crie-o no diretório ~/project. Você pode fazer isso clicando com o botão direito no File Explorer à esquerda, selecionando "New File" e digitando EvenCheck.java.
Adicione o seguinte código ao arquivo EvenCheck.java:
```
public class EvenCheck {
    public static void main(String[] args) {
        int number = 10; // We'll check if this number is even

        // Use the modulo operator to check for a remainder when divided by 2
        if (number % 2 == 0) {
            System.out.println(number + " is an even number.");
        } else {
            System.out.println(number + " is an odd number.");
        }
    }
}
```
Vamos analisar as novas partes:
- int number = 10;: Isso declara uma variável inteira chamada number e atribui a ela o valor 10. Podemos alterar esse valor para testar números diferentes.
- if (number % 2 == 0): Esta é uma instrução if. Ela verifica se a condição dentro dos parênteses é verdadeira. A condição number % 2 == 0 verifica se o resto de number dividido por 2 é igual a 0.
- System.out.println(number + " is an even number.");: Esta linha é executada se a condição na instrução if for verdadeira (o número é par).
- else: Esta palavra-chave introduz o bloco de código a ser executado se a condição na instrução if for falsa (o número é ímpar).
- System.out.println(number + " is an odd number.");: Esta linha é executada se o número for ímpar.
Salve o arquivo EvenCheck.java (Ctrl+S ou Cmd+S).
Agora, compile o programa. Abra o Terminal na parte inferior do WebIDE e certifique-se de estar no diretório ~/project. Em seguida, execute o seguinte comando:
```
javac EvenCheck.java
```
Se não houver erros, um arquivo EvenCheck.class será criado.
Finalmente, execute o programa compilado:
```
java EvenCheck
```
Você deve ver a saída indicando se o número 10 é par ou ímpar.
```
10 is an even number.
```

Agora, tente alterar o valor da variável number no arquivo EvenCheck.java para um inteiro diferente (por exemplo, 7, -5, 0) e repita as etapas 3, 4 e 5 para ver como a saída muda.

Testar com Números Positivos e Negativos

Na etapa anterior, verificamos com sucesso se um inteiro positivo é par ou ímpar. Agora, vamos explorar como o operador módulo funciona com números negativos e zero. O conceito de par e ímpar se aplica a todos os inteiros, incluindo os negativos e o zero.

Um inteiro é par se for divisível por 2, o que significa que o resto é 0. Essa definição também é válida para números negativos. Por exemplo, -4 é par porque -4 dividido por 2 é -2 com um resto de 0. -3 é ímpar porque -3 dividido por 2 é -1 com um resto de -1 (ou 1, dependendo da definição de módulo para números negativos, mas o importante é que não é 0). Zero também é considerado um número par porque 0 dividido por 2 é 0 com um resto de 0.

Vamos modificar nosso programa EvenCheck.java para testar com diferentes números positivos e negativos, bem como zero.

Abra o arquivo EvenCheck.java no editor WebIDE.
Modifique o método main para testar vários números diferentes. Você pode alterar o valor da variável number várias vezes, ou pode adicionar mais blocos if-else para verificar diferentes números sequencialmente. Para simplificar, vamos alterar o valor de number e executar o programa novamente para cada caso de teste.

Primeiro, vamos testar com um número ímpar positivo. Altere a linha int number = 10; para:
```
int number = 7; // Teste com um número ímpar positivo
```
Salve o arquivo.
Compile o programa modificado no Terminal:
```
javac EvenCheck.java
```
Execute o programa:
```
java EvenCheck
```
Você deve ver a saída:
```
7 is an odd number.
```
Agora, vamos testar com um número par negativo. Altere a linha int number = 7; para:
```
int number = -4; // Teste com um número par negativo
```
Salve o arquivo.
Compile o programa:
```
javac EvenCheck.java
```
Execute o programa:
```
java EvenCheck
```
Você deve ver a saída:
```
-4 is an even number.
```
Em seguida, teste com um número ímpar negativo. Altere a linha int number = -4; para:
```
int number = -3; // Teste com um número ímpar negativo
```
Salve o arquivo.
Compile o programa:
```
javac EvenCheck.java
```
Execute o programa:
```
java EvenCheck
```
Você deve ver a saída:
```
-3 is an odd number.
```
Finalmente, teste com zero. Altere a linha int number = -3; para:
```
int number = 0; // Teste com zero
```
Salve o arquivo.
Compile o programa:
```
javac EvenCheck.java
```
Execute o programa:
```
java EvenCheck
```
Você deve ver a saída:
```
0 is an even number.
```

Como você pode ver, o operador módulo identifica corretamente números pares e ímpares para valores positivos, negativos e zero. A lógica number % 2 == 0 é uma maneira confiável de verificar a paridade para qualquer inteiro.

Lidar com Entradas Não Inteiras

Nas etapas anteriores, usamos com sucesso o operador módulo para verificar se números inteiros são pares ou ímpares. No entanto, o que acontece se o usuário tentar inserir algo que não é um inteiro, como um número decimal ou texto? Nosso programa atual foi projetado para funcionar com inteiros (int), e fornecer uma entrada não inteira causará um erro.

Nesta etapa, modificaremos nosso programa para receber entrada do usuário e lidar com casos em que a entrada não é um inteiro válido. Usaremos a classe Scanner, que vimos brevemente em "Seu Primeiro Lab em Java", para ler a entrada do usuário.

Abra o arquivo EvenCheck.java no editor WebIDE.
Substitua todo o conteúdo do arquivo pelo seguinte código:
```
import java.util.Scanner;
import java.util.InputMismatchException;

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

        System.out.print("Enter an integer: ");

        try {
            int number = scanner.nextInt(); // Read integer input from the user

            // Use the modulo operator to check for a remainder when divided by 2
            if (number % 2 == 0) {
                System.out.println(number + " is an even number.");
            } else {
                System.out.println(number + " is an odd number.");
            }

        } catch (InputMismatchException e) {
            System.out.println("Invalid input. Please enter an integer.");
        } finally {
            scanner.close(); // Close the scanner
        }
    }
}
```
Vamos analisar as mudanças:
- import java.util.Scanner;: Importa a classe Scanner para ler a entrada.
- import java.util.InputMismatchException;: Importa a classe de exceção que é lançada quando a entrada não corresponde ao tipo esperado.
- Scanner scanner = new Scanner(System.in);: Cria um objeto Scanner para ler a entrada do console.
- System.out.print("Enter an integer: ");: Solicita ao usuário que insira um número.
- try { ... } catch (InputMismatchException e) { ... }: Este é um bloco try-catch, que é usado para tratamento de erros. O código dentro do bloco try é executado. Se ocorrer uma InputMismatchException (o que significa que a entrada não é um inteiro), o código dentro do bloco catch é executado.
- int number = scanner.nextInt();: Esta linha tenta ler um inteiro da entrada do usuário. Se o usuário inserir algo que não pode ser interpretado como um inteiro, uma InputMismatchException é lançada.
- System.out.println("Invalid input. Please enter an integer.");: Esta mensagem é impressa se uma InputMismatchException for capturada.
- finally { scanner.close(); }: O código dentro do bloco finally é sempre executado, independentemente de uma exceção ter ocorrido ou não. É usado aqui para fechar o recurso Scanner.
Salve o arquivo.
Compile o programa modificado no Terminal:
```
javac EvenCheck.java
```
Execute o programa:
```
java EvenCheck
```
Quando solicitado, insira um inteiro (por exemplo, 15) e pressione Enter. O programa deve identificar corretamente se é par ou ímpar.
```
Enter an integer: 15
15 is an odd number.
```
Execute o programa novamente:
```
java EvenCheck
```
Desta vez, quando solicitado, insira um valor não inteiro (por exemplo, hello ou 3.14) e pressione Enter. O programa agora deve lidar com a entrada inválida de forma adequada.
```
Enter an integer: hello
Invalid input. Please enter an integer.
```

Ao adicionar o bloco try-catch, nosso programa agora é mais robusto e pode lidar com casos em que o usuário fornece uma entrada que não está no formato esperado. Este é um aspecto importante da escrita de programas fáceis de usar.

Resumo

Neste laboratório, aprendemos como verificar se um número é par em Java usando o operador módulo (%). Descobrimos que um número par tem um resto de 0 quando dividido por 2. Implementamos um programa Java simples usando uma instrução if-else para realizar essa verificação e imprimir se um determinado inteiro é par ou ímpar.

Exploramos ainda o teste da verificação de paridade com entradas de inteiros positivos e negativos para garantir que o operador módulo se comporte como esperado para diferentes sinais. Finalmente, consideramos como lidar com entradas não inteiras, entendendo que o operador módulo é tipicamente usado com tipos inteiros e discutindo abordagens potenciais para validar tipos de entrada ou lidar com exceções em uma aplicação mais robusta.