Comment vérifier si un nombre est divisible par un autre en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un nombre est divisible par un autre en Java. Nous explorerons l'utilisation de l'opérateur modulo (%) pour déterminer la divisibilité en vérifiant si le reste d'une division est égal à zéro.

Vous allez pratiquer l'utilisation de l'opérateur modulo avec différents nombres et diviseurs, et apprendre également à gérer le cas particulier de la division par zéro pour éviter les erreurs dans vos programmes Java.

Utiliser le modulo pour vérifier la divisibilité

Dans cette étape, nous allons explorer comment utiliser l'opérateur modulo (%) en Java pour vérifier la divisibilité. L'opérateur modulo vous donne le reste d'une division. Si le reste d'une division est égal à 0, cela signifie que le nombre est parfaitement divisible par le diviseur.

Créons un nouveau programme Java pour illustrer cela.

Ouvrez le répertoire ~/project dans l'explorateur de fichiers à gauche.
Cliquez avec le bouton droit dans l'espace vide du répertoire ~/project et sélectionnez "Nouveau fichier".
Nommez le nouveau fichier DivisibilityCheck.java.
Ouvrez le fichier DivisibilityCheck.java dans l'éditeur de code.
Copiez et collez le code suivant dans l'éditeur :
```
public class DivisibilityCheck {
    public static void main(String[] args) {
        int number = 10;
        int divisor = 2;

        // Use the modulo operator to check for divisibility
        if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }

        number = 11;
        divisor = 3;

        if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }
    }
}
```
Examinons les nouvelles parties :
- int number = 10; : Cela déclare une variable entière nommée number et lui assigne la valeur 10.
- int divisor = 2; : Cela déclare une variable entière nommée divisor et lui assigne la valeur 2.
- number % divisor : Il s'agit de l'opération modulo. Elle calcule le reste lorsque number est divisé par divisor.
- if (number % divisor == 0) : Il s'agit d'une instruction if. Elle vérifie si le résultat de l'opération modulo est égal à 0. Si c'est le cas, le code à l'intérieur du bloc if est exécuté.
- else : Si la condition de l'instruction if est fausse (le reste n'est pas égal à 0), le code à l'intérieur du bloc else est exécuté.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Ouvrez le terminal en bas de l'IDE Web. Assurez-vous que vous êtes dans le répertoire ~/project. Sinon, tapez cd ~/project et appuyez sur Entrée.
Compilez le programme Java en tapant la commande suivante et en appuyant sur Entrée :
```
javac DivisibilityCheck.java
```
S'il n'y a pas d'erreurs, vous ne verrez aucun résultat. Un fichier DivisibilityCheck.class sera créé dans le répertoire ~/project.
Exécutez le programme Java compilé en tapant la commande suivante et en appuyant sur Entrée :
```
java DivisibilityCheck
```
Vous devriez voir le résultat suivant :
```
10 is divisible by 2
11 is not divisible by 3
```

Ce résultat confirme que notre programme a correctement utilisé l'opérateur modulo pour vérifier la divisibilité.

Tester avec différents diviseurs

Dans l'étape précédente, nous avons vérifié la divisibilité de 10 par 2 et de 11 par 3. Maintenant, modifions notre programme pour tester avec différents nombres et diviseurs afin de voir comment se comporte l'opérateur modulo.

Ouvrez le fichier DivisibilityCheck.java dans l'éditeur de l'IDE Web s'il n'est pas déjà ouvert.

Ajoutons quelques exemples supplémentaires à la méthode main. Ajoutez les lignes de code suivantes avant la accolade fermante } de la méthode main :


        System.out.println("\nTesting with different numbers:");

        number = 15;
        divisor = 5;
        if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }

        number = 20;
        divisor = 7;
        if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }

        number = 100;
        divisor = 10;
        if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }

Nous avons ajouté trois nouvelles vérifications avec différentes valeurs pour number et divisor. La ligne System.out.println("\nTesting with different numbers:"); ajoute simplement une ligne vide et un titre pour rendre la sortie plus claire.

Enregistrez le fichier DivisibilityCheck.java modifié (Ctrl+S ou Cmd+S).
Ouvrez le terminal et assurez-vous que vous êtes dans le répertoire ~/project.
Compilez le programme Java mis à jour :
```
javac DivisibilityCheck.java
```
Encore une fois, si la compilation réussit, vous ne verrez aucun résultat.
Exécutez le programme compilé pour voir les résultats avec les nouveaux cas de test :
```
java DivisibilityCheck
```
Vous devriez maintenant voir la sortie de l'étape précédente, suivie de la sortie des nouveaux cas de test :
```
10 is divisible by 2
11 is not divisible by 3

Testing with different numbers:
15 is divisible by 5
20 is not divisible by 7
100 is divisible by 10
```

En ajoutant ces cas de test, vous pouvez voir comment l'opérateur modulo identifie correctement si un nombre est parfaitement divisible par un autre nombre. C'est un concept fondamental utilisé dans de nombreuses tâches de programmation, comme la vérification des nombres pairs ou impairs, ou l'exécution d'actions à intervalles réguliers.

Gérer la division par zéro

En mathématiques, la division par zéro est indéfinie. En programmation, tenter de diviser par zéro (ou d'effectuer une opération modulo avec zéro comme diviseur) entraînera généralement une erreur. Il est important de gérer cette situation dans votre code pour éviter que votre programme ne plante.

Modifions notre programme DivisibilityCheck.java pour inclure une vérification de la division par zéro.

Ouvrez le fichier DivisibilityCheck.java dans l'éditeur de l'IDE Web.
Nous allons ajouter un nouveau cas de test où le diviseur est 0. Ajoutez le code suivant avant la accolade fermante } de la méthode main :
```
        System.out.println("\nTesting division by zero:");

        number = 10;
        divisor = 0;

        if (divisor == 0) {
            System.out.println("Error: Division by zero is not allowed.");
        } else if (number % divisor == 0) {
            System.out.println(number + " is divisible by " + divisor);
        } else {
            System.out.println(number + " is not divisible by " + divisor);
        }
```
Voici ce que nous avons ajouté :
- if (divisor == 0) : Il s'agit d'une nouvelle instruction if qui vérifie si la variable divisor est égale à 0.
- System.out.println("Error: Division by zero is not allowed."); : Si le diviseur est 0, cette ligne affiche un message d'erreur.
- else if (number % divisor == 0) : Il s'agit d'une instruction else if. Elle est vérifiée uniquement si la première condition if (divisor == 0) est fausse. C'est ici que nous effectuons la vérification modulo, mais seulement si le diviseur n'est pas zéro.
Enregistrez le fichier DivisibilityCheck.java modifié.
Ouvrez le terminal et assurez-vous que vous êtes dans le répertoire ~/project.
Compilez le programme Java mis à jour :
```
javac DivisibilityCheck.java
```

Exécutez le programme compilé :

java DivisibilityCheck

Vous devriez voir la sortie des étapes précédentes, suivie de la sortie pour le cas de test de la division par zéro :

10 is divisible by 2
11 is not divisible by 3

Testing with different numbers:
15 is divisible by 5
20 is not divisible by 7
100 is divisible by 10

Testing division by zero:
Error: Division by zero is not allowed.

En ajoutant la vérification if (divisor == 0), nous avons rendu notre programme plus robuste en évitant une erreur potentielle lorsque le diviseur est zéro. C'est un aspect important de l'écriture de code fiable.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si un nombre est divisible par un autre nombre en Java en utilisant l'opérateur modulo (%). Nous avons créé un programme Java DivisibilityCheck.java et utilisé l'instruction if pour vérifier si le reste de la division (number % divisor) est égal à 0. Si le reste est 0, le nombre est divisible par le diviseur. Nous avons démontré cela avec des exemples où le nombre est divisible et d'autres où il ne l'est pas.