Como Verificar se um Número é Ímpar ou Par em Java

Introdução

Neste laboratório, você aprenderá como determinar se um número é ímpar ou par em Java usando o operador módulo (modulo operator). Exploraremos o conceito do operador módulo e como seu resultado ao dividir por 2 pode distinguir entre números ímpares e pares.

Através de passos práticos, você aplicará o operador módulo para verificar números ímpares, verificará a lógica com vários tipos de números e combinará verificações para números pares e ímpares, ganhando experiência prática em lógica condicional em Java.

Aplicar o Operador Módulo para Verificação de Ímpar

Nesta etapa, aprenderemos como determinar se um número é ímpar ou par usando o operador módulo em Java. 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 se for perfeitamente divisível por 2, o que significa que o resto ao dividir por 2 é 0. Um número é ímpar se o resto ao dividir por 2 for 1.

Vamos criar um novo programa Java para verificar se um número é ímpar.

Abra o arquivo HelloJava.java no editor WebIDE, caso ainda não esteja aberto.
Substitua todo o conteúdo do arquivo pelo seguinte código:
```
import java.util.Scanner;

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

        System.out.print("Enter an integer: ");
        int number = scanner.nextInt();

        // Check if the number is odd using the modulo operator
        if (number % 2 != 0) {
            System.out.println(number + " is an odd number.");
        } else {
            System.out.println(number + " is an even number.");
        }

        scanner.close();
    }
}
```
Vamos analisar as novas partes do código:
- int number = scanner.nextInt();: Esta linha lê um valor inteiro inserido pelo usuário e o armazena em uma variável chamada number.
- if (number % 2 != 0): Esta é uma instrução if, que permite que nosso programa tome decisões. Ela verifica se o resto de number dividido por 2 é diferente de 0. O símbolo != significa "diferente de".
- System.out.println(number + " is an odd number.");: Esta linha é executada se a condição na instrução if for verdadeira (o número é ímpar).
- 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 é par).
- System.out.println(number + " is an even number.");: Esta linha é executada se o número for par.
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado no Terminal:
```
javac HelloJava.java
```
Se não houver erros, um arquivo HelloJava.class será criado.
Execute o programa compilado:
```
java HelloJava
```
O programa solicitará que você insira um inteiro. Insira um número (por exemplo, 7) e pressione Enter. O programa deve informar se o número é ímpar ou par.
```
Enter an integer: 7
7 is an odd number.
```
Execute o programa novamente e insira um número par (por exemplo, 10).
```
Enter an integer: 10
10 is an even number.
```

Você usou com sucesso o operador módulo e uma instrução if-else para verificar se um número é ímpar ou par. Este é um conceito fundamental em programação para controlar o fluxo do seu programa com base em condições.

Verificar com Vários Tipos de Números

Na etapa anterior, verificamos com sucesso se um inteiro é ímpar ou par. Agora, vamos explorar como o operador módulo se comporta com diferentes tipos de números, focando especificamente em inteiros negativos.

O conceito de números ímpares e pares normalmente se aplica a inteiros. No entanto, é importante entender como o operador módulo funciona com números negativos em Java, pois ele pode se comportar de maneira diferente do que você espera com base em definições matemáticas.

Em Java, o resultado da operação módulo (a % b) tem o mesmo sinal do dividendo (a).

Vamos modificar nosso programa para testar com números negativos.

Abra o arquivo HelloJava.java no editor WebIDE.

O código atual já lê um inteiro. Podemos usar o mesmo código e simplesmente inserir números negativos ao executar o programa.

import java.util.Scanner;

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

        System.out.print("Enter an integer: ");
        int number = scanner.nextInt();

        // Check if the number is odd using the modulo operator
        if (number % 2 != 0) {
            System.out.println(number + " is an odd number.");
        } else {
            System.out.println(number + " is an even number.");
        }

        scanner.close();
    }
}

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa novamente para garantir que você tenha a versão mais recente:
```
javac HelloJava.java
```
Execute o programa:
```
java HelloJava
```
Quando solicitado, insira um número ímpar negativo (por exemplo, -7) e observe a saída.
```
Enter an integer: -7
-7 is an odd number.
```
A saída identifica corretamente -7 como ímpar porque -7 dividido por 2 é -3 com um resto de -1. Como -1 não é igual a 0, a condição if number % 2 != 0 é verdadeira.
Execute o programa novamente e insira um número par negativo (por exemplo, -10).
```
Enter an integer: -10
-10 is an even number.
```
A saída identifica corretamente -10 como par porque -10 dividido por 2 é -5 com um resto de 0. A condição if number % 2 != 0 é falsa, e o bloco else é executado.

Isso demonstra que nossa lógica atual para verificar números ímpares/pares usando o operador módulo funciona corretamente para inteiros positivos e negativos em Java. A chave é que o resto de um número ímpar dividido por 2 sempre será diferente de zero (1 ou -1), enquanto o resto de um número par dividido por 2 sempre será 0.

Combinar Verificações de Par e Ímpar

Nas etapas anteriores, aprendemos como usar o operador módulo para verificar se um número é ímpar ou par. Nosso programa atual já lida com ambos os casos usando uma instrução if-else.

Nesta etapa, revisaremos o código e garantiremos que entendemos como a estrutura if-else combina efetivamente as verificações para números pares e ímpares.

Recorde o código que usamos na etapa anterior:

import java.util.Scanner;

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

        System.out.print("Enter an integer: ");
        int number = scanner.nextInt();

        // Check if the number is odd using the modulo operator
        if (number % 2 != 0) {
            System.out.println(number + " is an odd number.");
        } else {
            System.out.println(number + " is an even number.");
        }

        scanner.close();
    }
}

Vamos analisar a lógica novamente:

A condição number % 2 != 0 verifica se o resto quando number é dividido por 2 é diferente de 0.
Se esta condição for true, significa que o número é ímpar, e o código dentro do bloco if é executado: System.out.println(number + " is an odd number.");.
Se a condição number % 2 != 0 for false, significa que o resto é igual a 0. Nesse caso, o número deve ser par, e o código dentro do bloco else é executado: System.out.println(number + " is an even number.");.

Esta estrutura if-else é uma maneira muito comum de lidar com duas possibilidades mutuamente exclusivas (ou um número é ímpar ou é par). Não precisamos de uma verificação separada para números pares porque, se um número não é ímpar, ele deve ser par (para inteiros).

Para concluir esta etapa, simplesmente certifique-se de que seu arquivo HelloJava.java contém o código correto, conforme mostrado acima.

Abra o arquivo HelloJava.java no editor WebIDE.
Verifique se o código corresponde ao exemplo fornecido acima, incluindo a importação (import), o uso do Scanner, o prompt, a leitura do inteiro, a instrução if-else com a verificação do módulo e o fechamento do scanner.
Salve o arquivo se você fez alguma alteração (Ctrl+S ou Cmd+S).
Compile o programa mais uma vez para ter certeza:
```
javac HelloJava.java
```
Execute o programa e teste-o com números ímpares e pares (positivos e negativos) para confirmar se ele funciona conforme o esperado.
```
java HelloJava
```
Exemplo de saída para um número ímpar:
```
Enter an integer: 9
9 is an odd number.
```
Exemplo de saída para um número par:
```
Enter an integer: -4
-4 is an even number.
```

Você agora implementou e verificou com sucesso um programa Java que usa o operador módulo e uma instrução if-else para determinar se um inteiro é ímpar ou par. Este conceito fundamental de lógica condicional é crucial para a construção de programas mais complexos.

Resumo

Neste laboratório, aprendemos como determinar se um número é ímpar ou par em Java usando o operador módulo (%). Descobrimos que um número é par se o resto da divisão por 2 for 0, e ímpar se o resto for 1. Implementamos essa lógica em um programa Java que recebe a entrada do usuário e imprime se o número é ímpar ou par.

Também exploramos como verificar essa checagem com vários tipos de números e como combinar a lógica para verificações de pares e ímpares dentro de um único programa usando uma instrução if-else. Essa experiência prática proporcionou uma compreensão prática das instruções condicionais e do operador módulo em Java para verificações básicas de propriedades numéricas.

Como Verificar se um Número é Ímpar em Java

Introdução

Aplicar o Operador Módulo para Verificação de Ímpar

Verificar com Vários Tipos de Números

Combinar Verificações de Par e Ímpar

Resumo