Comment vérifier si un nombre est pair en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à déterminer si un nombre est pair ou impair en Java. Nous explorerons l'utilisation de l'opérateur modulo (%) pour vérifier le reste lorsqu'un nombre est divisé par 2, ce qui est le principe fondamental pour identifier les nombres pairs.

Vous allez implémenter un simple programme Java pour effectuer cette vérification, le tester avec des entrées entières positives et négatives, et réfléchir à la manière de gérer les entrées non entières pour rendre votre solution plus robuste.

Skills Graph

Utilisation de l'opérateur modulo pour vérifier si un nombre est pair

Dans cette étape, nous apprendrons à déterminer si un nombre est pair ou impair en Java en utilisant l'opérateur modulo. 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 pair est tout entier qui peut être divisé par 2 sans reste. Cela signifie que si vous divisez un nombre pair par 2, le reste est toujours 0. Nous pouvons utiliser l'opérateur modulo pour vérifier cette condition.

Créons un simple programme Java pour vérifier si un nombre est pair.

1. Ouvrez le fichier EvenCheck.java dans l'éditeur WebIDE. Si le fichier n'existe pas, créez - le dans le répertoire ~/project. Vous pouvez le faire en cliquant avec le bouton droit dans l'explorateur de fichiers à gauche, en sélectionnant "Nouveau fichier" et en tapant EvenCheck.java.

2. Ajoutez le code suivant au fichier EvenCheck.java :

   public class EvenCheck {
       public static void main(String[] args) {
           int number = 10; // Nous allons vérifier si ce nombre est pair
   
           // Utilisez l'opérateur modulo pour vérifier le reste lors de la division par 2
           if (number % 2 == 0) {
               System.out.println(number + " is an even number.");
           } else {
               System.out.println(number + " is an odd number.");
           }
       }
   }

   Examinons les nouvelles parties :

   • int number = 10; : Cela déclare une variable entière nommée number et lui assigne la valeur 10. Nous pouvons changer cette valeur pour tester différents nombres.
   • if (number % 2 == 0) : Il s'agit d'une instruction if. Elle vérifie si la condition entre parenthèses est vraie. La condition number % 2 == 0 vérifie si le reste de la division de number par 2 est égal à 0.
   • System.out.println(number + " is an even number."); : Cette ligne est exécutée si la condition de l'instruction if est vraie (le nombre est pair).
   • else : Ce mot - clé introduit le bloc de code à exécuter si la condition de l'instruction if est fausse (le nombre est impair).
   • System.out.println(number + " is an odd number."); : Cette ligne est exécutée si le nombre est impair.

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

4. Maintenant, compilez le programme. Ouvrez le terminal en bas de l'éditeur WebIDE et assurez - vous que vous êtes dans le répertoire ~/project. Ensuite, exécutez la commande suivante :

   javac EvenCheck.java

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

5. Enfin, exécutez le programme compilé :

   java EvenCheck

   Vous devriez voir la sortie indiquant si le nombre 10 est pair ou impair.

   10 is an even number.

Maintenant, essayez de changer la valeur de la variable number dans le fichier EvenCheck.java pour un autre entier (par exemple, 7, -5, 0) et répétez les étapes 3, 4 et 5 pour voir comment la sortie change.

Tester avec des nombres positifs et négatifs

Dans l'étape précédente, nous avons réussi à vérifier si un entier positif est pair ou impair. Maintenant, explorons comment l'opérateur modulo fonctionne avec les nombres négatifs et le zéro. Le concept de pair et impair s'applique à tous les entiers, y compris les nombres négatifs et le zéro.

Un entier est pair s'il est divisible par 2, c'est - à - dire que le reste est 0. Cette définition est également valable pour les nombres négatifs. Par exemple, -4 est pair car -4 divisé par 2 donne -2 avec un reste de 0. -3 est impair car -3 divisé par 2 donne -1 avec un reste de -1 (ou 1, selon la définition du modulo pour les nombres négatifs, mais l'essentiel est que ce n'est pas 0). Le zéro est également considéré comme un nombre pair car 0 divisé par 2 donne 0 avec un reste de 0.

Modifions notre programme EvenCheck.java pour tester avec différents nombres positifs, négatifs et le zéro.

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

2. Modifiez la méthode main pour tester plusieurs nombres différents. Vous pouvez changer la valeur de la variable number plusieurs fois, ou vous pouvez ajouter plus de blocs if-else pour vérifier différents nombres séquentiellement. Pour simplifier, changeons la valeur de number et relançons le programme pour chaque cas de test.

   Tout d'abord, testons avec un nombre impair positif. Changez la ligne int number = 10; en :

   int number = 7; // Test with a positive odd number

3. Enregistrez le fichier.

4. Compilez le programme modifié dans le terminal :

   javac EvenCheck.java

5. Exécutez le programme :

   java EvenCheck

   Vous devriez voir la sortie suivante :

   7 is an odd number.

6. Maintenant, testons avec un nombre pair négatif. Changez la ligne int number = 7; en :

   int number = -4; // Test with a negative even number

7. Enregistrez le fichier.

8. Compilez le programme :

   javac EvenCheck.java

9. Exécutez le programme :

   java EvenCheck

   Vous devriez voir la sortie suivante :

   -4 is an even number.

10. Ensuite, testons avec un nombre impair négatif. Changez la ligne int number = -4; en :

    int number = -3; // Test with a negative odd number

11. Enregistrez le fichier.

12. Compilez le programme :

    javac EvenCheck.java

13. Exécutez le programme :

    java EvenCheck

    Vous devriez voir la sortie suivante :

    -3 is an odd number.

14. Enfin, testons avec le zéro. Changez la ligne int number = -3; en :

    int number = 0; // Test with zero

15. Enregistrez le fichier.

16. Compilez le programme :

    javac EvenCheck.java

17. Exécutez le programme :

    java EvenCheck

    Vous devriez voir la sortie suivante :

    0 is an even number.

Comme vous pouvez le voir, l'opérateur modulo identifie correctement les nombres pairs et impairs pour les valeurs positives, négatives et le zéro. La logique number % 2 == 0 est un moyen fiable de vérifier si un entier est pair.

Gérer les entrées non entières

Dans les étapes précédentes, nous avons réussi à utiliser l'opérateur modulo pour vérifier si des nombres entiers sont pairs ou impairs. Cependant, que se passe - t - il si l'utilisateur essaie d'entrer quelque chose qui n'est pas un entier, comme un nombre décimal ou du texte ? Notre programme actuel est conçu pour fonctionner avec des entiers (int), et fournir une entrée non entière entraînera une erreur.

Dans cette étape, nous allons modifier notre programme pour prendre des entrées de l'utilisateur et gérer les cas où l'entrée n'est pas un entier valide. Nous allons utiliser la classe Scanner, que nous avons brièvement vue dans le "Your First Java Lab", pour lire les entrées de l'utilisateur.

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

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

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

   Examinons les modifications :

   • import java.util.Scanner; : Importe la classe Scanner pour lire les entrées.
   • import java.util.InputMismatchException; : Importe la classe d'exception qui est levée lorsque l'entrée ne correspond pas au type attendu.
   • Scanner scanner = new Scanner(System.in); : Crée un objet Scanner pour lire les entrées depuis la console.
   • System.out.print("Enter an integer: "); : Invite l'utilisateur à entrer un nombre.
   • try { ... } catch (InputMismatchException e) { ... } : Il s'agit d'un bloc try-catch, qui est utilisé pour la gestion des erreurs. Le code à l'intérieur du bloc try est exécuté. Si une InputMismatchException se produit (ce qui signifie que l'entrée n'est pas un entier), le code à l'intérieur du bloc catch est exécuté.
   • int number = scanner.nextInt(); : Cette ligne tente de lire un entier depuis l'entrée de l'utilisateur. Si l'utilisateur entre quelque chose qui ne peut pas être interprété comme un entier, une InputMismatchException est levée.
   • System.out.println("Invalid input. Please enter an integer."); : Ce message est affiché si une InputMismatchException est capturée.
   • finally { scanner.close(); } : Le code à l'intérieur du bloc finally est toujours exécuté, que l'exception se soit produite ou non. Il est utilisé ici pour fermer la ressource Scanner.

3. Enregistrez le fichier.

4. Compilez le programme modifié dans le terminal :

   javac EvenCheck.java

5. Exécutez le programme :

   java EvenCheck

6. Lorsque vous êtes invité, entrez un entier (par exemple, 15) et appuyez sur Entrée. Le programme devrait correctement identifier si le nombre est pair ou impair.

   Enter an integer: 15
   15 is an odd number.

7. Exécutez le programme à nouveau :

   java EvenCheck

8. Cette fois - ci, lorsque vous êtes invité, entrez une valeur non entière (par exemple, hello ou 3.14) et appuyez sur Entrée. Le programme devrait maintenant gérer l'entrée invalide de manière gracieuse.

   Enter an integer: hello
   Invalid input. Please enter an integer.

En ajoutant le bloc try-catch, notre programme est maintenant plus robuste et peut gérer les cas où l'utilisateur fournit une entrée qui n'est pas au format attendu. C'est un aspect important de l'écriture de programmes conviviaux pour l'utilisateur.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si un nombre est pair en Java en utilisant l'opérateur modulo (%). Nous avons découvert qu'un nombre pair a un reste égal à 0 lorsqu'il est divisé par 2. Nous avons implémenté un simple programme Java en utilisant une instruction if-else pour effectuer cette vérification et afficher si un entier donné est pair ou impair.

Nous avons ensuite exploré le test de la vérification de la parité avec des entrées d'entiers positifs et négatifs pour nous assurer que l'opérateur modulo se comporte comme prévu pour différents signes. Enfin, nous avons examiné comment gérer les entrées non entières, en comprenant que l'opérateur modulo est généralement utilisé avec des types entiers et en discutant des approches possibles pour valider les types d'entrée ou gérer les exceptions dans une application plus robuste.