Comment vérifier si un nombre est impair en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à déterminer si un nombre est impair ou pair en Java en utilisant l'opérateur modulo. Nous explorerons le concept de l'opérateur modulo et comment son résultat lors de la division par 2 peut distinguer les nombres impairs des nombres pairs.

À travers des étapes pratiques, vous appliquerez l'opérateur modulo pour vérifier les nombres impairs, vérifierez la logique avec différents types de nombres et combinerez les vérifications pour les nombres pairs et impairs, en acquérant une expérience pratique en logique conditionnelle en Java.

Skills Graph

Appliquer l'opérateur modulo pour vérifier si un nombre est impair

Dans cette étape, nous apprendrons à déterminer si un nombre est impair ou pair en utilisant l'opérateur modulo en Java. L'opérateur modulo (%) vous donne le reste d'une division. Par exemple, 10 % 3 vaut 1 car 10 divisé par 3 donne 3 avec un reste de 1.

Un nombre est pair s'il est parfaitement divisible par 2, c'est-à-dire que le reste de la division par 2 est égal à 0. Un nombre est impair si le reste de la division par 2 est égal à 1.

Créons un nouveau programme Java pour vérifier si un nombre est impair.

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE s'il n'est pas déjà ouvert.

2. Remplacez tout le contenu du fichier par le code suivant :

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

   Examinons les nouvelles parties du code :

   • int number = scanner.nextInt(); : Cette ligne lit une valeur entière saisie par l'utilisateur et la stocke dans une variable nommée number.
   • if (number % 2 != 0) : Il s'agit d'une instruction if, qui permet à notre programme de prendre des décisions. Elle vérifie si le reste de la division de number par 2 est différent de 0. Le symbole != signifie "différent de".
   • System.out.println(number + " is an odd number."); : Cette ligne est exécutée si la condition de l'instruction if est vraie (le nombre est impair).
   • else : Ce mot-clé introduit le bloc de code à exécuter si la condition de l'instruction if est fausse (le nombre est pair).
   • System.out.println(number + " is an even number."); : Cette ligne est exécutée si le nombre est pair.

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Compilez le programme modifié dans le terminal :

   javac HelloJava.java

   S'il n'y a pas d'erreurs, un fichier HelloJava.class sera créé.

5. Exécutez le programme compilé :

   java HelloJava

6. Le programme vous demandera d'entrer un entier. Entrez un nombre (par exemple, 7) puis appuyez sur Entrée. Le programme devrait vous indiquer si le nombre est impair ou pair.

   Enter an integer: 7
   7 is an odd number.

   Exécutez le programme à nouveau et entrez un nombre pair (par exemple, 10).

   Enter an integer: 10
   10 is an even number.

Vous avez utilisé avec succès l'opérateur modulo et une instruction if-else pour vérifier si un nombre est impair ou pair. C'est un concept fondamental en programmation pour contrôler le flux de votre programme en fonction de conditions.

Vérifier avec différents types de nombres

Dans l'étape précédente, nous avons vérifié avec succès si un entier est impair ou pair. Maintenant, explorons le comportement de l'opérateur modulo avec différents types de nombres, en particulier les entiers négatifs.

Le concept de nombres impairs et pairs s'applique généralement aux entiers. Cependant, il est important de comprendre le fonctionnement de l'opérateur modulo avec les nombres négatifs en Java, car son comportement peut différer de ce que l'on s'attendrait d'après les définitions mathématiques.

En Java, le résultat de l'opération modulo (a % b) a le même signe que le dividende (a).

Modifions notre programme pour tester avec des nombres négatifs.

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

2. Le code actuel lit déjà un entier. Nous pouvons utiliser le même code et simplement entrer des nombres négatifs lors de l'exécution du programme.

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

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Compilez le programme à nouveau pour vous assurer que vous avez la dernière version :

   javac HelloJava.java

5. Exécutez le programme :

   java HelloJava

6. Lorsque vous y êtes invité, entrez un nombre impair négatif (par exemple, -7) et observez la sortie.

   Enter an integer: -7
   -7 is an odd number.

   La sortie identifie correctement -7 comme impair car -7 divisé par 2 donne -3 avec un reste de -1. Étant donné que -1 n'est pas égal à 0, la condition if number % 2 != 0 est vraie.

7. Exécutez le programme à nouveau et entrez un nombre pair négatif (par exemple, -10).

   Enter an integer: -10
   -10 is an even number.

   La sortie identifie correctement -10 comme pair car -10 divisé par 2 donne -5 avec un reste de 0. La condition if number % 2 != 0 est fausse, et le bloc else est exécuté.

Cela démontre que notre logique actuelle pour vérifier si un nombre est impair ou pair en utilisant l'opérateur modulo fonctionne correctement pour les entiers positifs et négatifs en Java. La clé est que le reste d'un nombre impair divisé par 2 sera toujours non nul (soit 1, soit -1), tandis que le reste d'un nombre pair divisé par 2 sera toujours 0.

Combiner les vérifications de nombres pairs et impairs

Dans les étapes précédentes, nous avons appris à utiliser l'opérateur modulo pour vérifier si un nombre est impair ou pair. Notre programme actuel gère déjà les deux cas à l'aide d'une instruction if-else.

Dans cette étape, nous allons revoir le code et nous assurer de comprendre comment la structure if-else combine efficacement les vérifications pour les nombres pairs et impairs.

Rappelons le code que nous avons utilisé dans l'étape précédente :

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

Décortiquons à nouveau la logique :

• La condition number % 2 != 0 vérifie si le reste de la division de number par 2 est différent de 0.
• Si cette condition est true, cela signifie que le nombre est impair, et le code à l'intérieur du bloc if est exécuté : System.out.println(number + " is an odd number.");.
• Si la condition number % 2 != 0 est false, cela signifie que le reste est égal à 0. Dans ce cas, le nombre doit être pair, et le code à l'intérieur du bloc else est exécuté : System.out.println(number + " is an even number.");.

Cette structure if-else est un moyen très courant de gérer deux possibilités mutuellement exclusives (soit un nombre est impair, soit il est pair). Nous n'avons pas besoin d'une vérification séparée pour les nombres pairs car si un nombre n'est pas impair, il doit être pair (pour les entiers).

Pour terminer cette étape, assurez-vous simplement que votre fichier HelloJava.java contient le bon code tel qu'indiqué ci-dessus.

1. Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

2. Vérifiez que le code correspond à l'exemple fourni ci-dessus, y compris l'instruction import, l'utilisation de Scanner, l'invite, la lecture de l'entier, l'instruction if-else avec la vérification modulo et la fermeture du scanner.

3. Enregistrez le fichier si vous avez apporté des modifications (Ctrl+S ou Cmd+S).

4. Compilez le programme une dernière fois pour être sûr :

   javac HelloJava.java

5. Exécutez le programme et testez-le avec des nombres impairs et pairs (positifs et négatifs) pour confirmer qu'il fonctionne comme prévu.

   java HelloJava

   Exemple de sortie pour un nombre impair :

   Enter an integer: 9
   9 is an odd number.

   Exemple de sortie pour un nombre pair :

   Enter an integer: -4
   -4 is an even number.

Vous avez maintenant implémenté et vérifié avec succès un programme Java qui utilise l'opérateur modulo et une instruction if-else pour déterminer si un entier est impair ou pair. Ce concept fondamental de logique conditionnelle est crucial pour la construction de programmes plus complexes.

Résumé

Dans ce laboratoire (lab), nous avons appris à déterminer si un nombre est impair ou pair en Java en utilisant l'opérateur modulo (%). Nous avons découvert qu'un nombre est pair si le reste de sa division par 2 est égal à 0, et impair si le reste est égal à 1. Nous avons implémenté cette logique dans un programme Java qui prend une entrée utilisateur et affiche si le nombre est impair ou pair.

Nous avons également exploré comment vérifier cette vérification avec différents types de nombres et comment combiner la logique pour les vérifications de nombres pairs et impairs dans un seul programme en utilisant une instruction if-else. Cette expérience pratique a fourni une compréhension concrète des instructions conditionnelles et de l'opérateur modulo en Java pour les vérifications de propriétés de base des nombres.