Comment vérifier si un nombre se trouve dans une plage spécifique en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un nombre appartient à une plage spécifique en Java. Nous aborderons les concepts fondamentaux de la définition d'une plage numérique en utilisant des bornes inférieure et supérieure, de l'utilisation d'opérateurs logiques pour effectuer la vérification de plage, et de la compréhension de la manière d'inclure les valeurs limites dans vos comparaisons de plage. Grâce à des exercices pratiques, vous acquerrez une expérience pratique dans la mise en œuvre de ces techniques dans le code Java.

Définir une plage avec des bornes inférieure et supérieure

Dans cette étape, nous apprendrons à définir une plage numérique en utilisant des bornes inférieure et supérieure en Java. Comprendre comment travailler avec des plages est un concept fondamental en programmation, car cela nous permet de vérifier si une valeur appartient à un ensemble spécifique de nombres.

Une plage est simplement un ensemble de nombres compris entre un point de départ (la borne inférieure) et un point d'arrivée (la borne supérieure). Par exemple, la plage entre 1 et 10 inclut tous les nombres de 1 à 10.

Créons un simple programme Java pour définir et travailler avec une plage.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE s'il n'est pas déjà ouvert. Nous allons modifier ce fichier pour notre nouveau programme.
Remplacez tout le contenu du fichier par le code suivant :
```
public class HelloJava {
    public static void main(String[] args) {
        // Define the lower and upper bounds of the range
        int lowerBound = 10;
        int upperBound = 50;

        // Print the defined range
        System.out.println("Defined Range: [" + lowerBound + ", " + upperBound + "]");
    }
}
```
Examinons les nouvelles parties de ce code :
- int lowerBound = 10; : Cette ligne déclare une variable entière nommée lowerBound et lui assigne la valeur 10. C'est notre point de départ pour la plage.
- int upperBound = 50; : Cette ligne déclare une variable entière nommée upperBound et lui assigne la valeur 50. C'est notre point d'arrivée pour la plage.
- System.out.println("Defined Range: [" + lowerBound + ", " + upperBound + "]"); : Cette ligne affiche un message dans la console montrant la plage définie en utilisant les valeurs de lowerBound et upperBound. Le symbole + est utilisé pour combiner des chaînes de texte et des valeurs de variables.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Maintenant, compilons notre programme modifié. Ouvrez le Terminal en bas de l'interface WebIDE et assurez-vous que vous êtes dans le répertoire ~/project. Ensuite, exécutez la commande suivante :
```
javac HelloJava.java
```
S'il n'y a pas d'erreurs, la compilation a réussi.
Enfin, exécutons le programme pour voir la sortie. Dans le Terminal, exécutez :
```
java HelloJava
```
Vous devriez voir la sortie suivante :
```
Defined Range: [10, 50]
```
Cela confirme que notre programme a correctement défini et affiché les bornes inférieure et supérieure de la plage.

Dans l'étape suivante, nous apprendrons à vérifier si un nombre appartient à cette plage définie en utilisant des opérateurs logiques.

Utiliser des opérateurs logiques pour la vérification de plage

Dans cette étape, nous apprendrons à utiliser des opérateurs logiques en Java pour vérifier si un nombre appartient à la plage que nous avons définie à l'étape précédente. Les opérateurs logiques sont utilisés pour combiner ou modifier des expressions booléennes (expressions qui sont soit vraies, soit fausses).

Pour vérifier si un nombre se trouve dans une plage définie par une borne inférieure et une borne supérieure, nous devons vérifier deux conditions :

Le nombre est-il supérieur ou égal à la borne inférieure ?
Le nombre est-il inférieur ou égal à la borne supérieure ?

Ces deux conditions doivent être vraies pour que le nombre appartienne à la plage. En Java, nous utilisons l'opérateur logique ET (&&) pour combiner ces deux conditions.

Modifions notre programme HelloJava.java pour inclure cette vérification de plage.

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

Modifiez la méthode main pour inclure une variable pour le nombre à vérifier et la logique de vérification de plage. Remplacez le contenu existant de la méthode main par le code suivant :

    public static void main(String[] args) {
        // Define the lower and upper bounds of the range
        int lowerBound = 10;
        int upperBound = 50;

        // Define the number to check
        int numberToCheck = 35;

        // Check if the number is within the range using logical operators
        boolean isInRange = (numberToCheck >= lowerBound) && (numberToCheck <= upperBound);

        // Print the result
        System.out.println("Defined Range: [" + lowerBound + ", " + upperBound + "]");
        System.out.println("Number to Check: " + numberToCheck);
        System.out.println("Is " + numberToCheck + " within the range? " + isInRange);
    }

Voici ce que nous avons ajouté :

int numberToCheck = 35; : Cette ligne déclare une variable entière numberToCheck et lui assigne la valeur 35. C'est le nombre que nous voulons vérifier par rapport à notre plage.
boolean isInRange = (numberToCheck >= lowerBound) && (numberToCheck <= upperBound); : C'est le cœur de notre vérification de plage.
- numberToCheck >= lowerBound : Cela vérifie si numberToCheck est supérieur ou égal à lowerBound.
- numberToCheck <= upperBound : Cela vérifie si numberToCheck est inférieur ou égal à upperBound.
- && : C'est l'opérateur logique ET. Il renvoie true seulement si les deux conditions à sa gauche et à sa droite sont true.
- Le résultat de cette expression entière (true ou false) est stocké dans une variable booléenne nommée isInRange.
Les lignes System.out.println affichent maintenant également le nombre vérifié et le résultat de la vérification de plage.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié dans le Terminal :
```
javac HelloJava.java
```
Exécutez le programme compilé :
```
java HelloJava
```

Vous devriez voir une sortie similaire à celle-ci :

Defined Range: [10, 50]
Number to Check: 35
Is 35 within the range? true

Étant donné que 35 est bien compris entre 10 et 50 (inclus), le programme affiche correctement true.

Essayez de changer la valeur de numberToCheck pour un nombre en dehors de la plage (par exemple, 5 ou 60) et recompilez et relancez le programme pour voir comment la sortie change.

Inclure les valeurs limites dans la plage

Dans l'étape précédente, nous avons utilisé les opérateurs >= (supérieur ou égal à) et <= (inférieur ou égal à) pour vérifier si un nombre se trouve dans une plage. Ces opérateurs sont essentiels car ils incluent les valeurs limites (les bornes inférieure et supérieure) dans la vérification de plage.

Par exemple, si notre plage est [10, 50], un nombre est considéré comme appartenant à la plage s'il est égal à 10, à 50 ou à n'importe quel nombre compris entre 10 et 50. Si nous avions utilisé > (supérieur à) et < (inférieur à) à la place, la plage serait (10, 50), ce qui signifie que 10 et 50 eux-mêmes ne seraient pas inclus.

Confirmons ce comportement en testant notre programme avec les valeurs limites.

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

Nous allons tester la vérification de plage avec la borne inférieure et la borne supérieure. Modifiez la méthode main pour tester à la fois lowerBound et upperBound comme numberToCheck.

public class HelloJava {
    public static void main(String[] args) {
        // Define the lower and upper bounds of the range
        int lowerBound = 10;
        int upperBound = 50;

        // Test with the lower bound
        int numberToCheck1 = lowerBound;
        boolean isInRange1 = (numberToCheck1 >= lowerBound) && (numberToCheck1 <= upperBound);
        System.out.println("Defined Range: [" + lowerBound + ", " + upperBound + "]");
        System.out.println("Number to Check: " + numberToCheck1);
        System.out.println("Is " + numberToCheck1 + " within the range? " + isInRange1);
        System.out.println("---"); // Separator for clarity

        // Test with the upper bound
        int numberToCheck2 = upperBound;
        boolean isInRange2 = (numberToCheck2 >= lowerBound) && (numberToCheck2 <= upperBound);
        System.out.println("Number to Check: " + numberToCheck2);
        System.out.println("Is " + numberToCheck2 + " within the range? " + isInRange2);
    }
}

Nous avons ajouté un deuxième cas de test en utilisant numberToCheck2 défini sur upperBound.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié dans le Terminal :
```
javac HelloJava.java
```
Exécutez le programme compilé :
```
java HelloJava
```

Vous devriez voir une sortie similaire à celle-ci :

Defined Range: [10, 50]
Number to Check: 10
Is 10 within the range? true
---
Number to Check: 50
Is 50 within the range? true

Comme vous pouvez le voir, tant 10 (la borne inférieure) que 50 (la borne supérieure) sont correctement identifiés comme appartenant à la plage car nous avons utilisé les opérateurs >= et <=. Cela confirme que notre vérification de plage inclut les valeurs limites.

Comprendre si une plage inclut ses limites (inclusive) ou les exclut (exclusive) est important lorsque vous définissez des conditions dans vos programmes. Les opérateurs >= et <= créent une plage inclusive.

Résumé

Dans ce laboratoire (lab), nous avons appris à définir une plage numérique en Java en définissant des bornes inférieure et supérieure à l'aide de variables entières. Nous avons modifié un simple programme Java pour déclarer ces bornes et afficher la plage définie dans la console, en comprenant comment combiner du texte et des valeurs de variables pour l'affichage. Cette étape fondamentale est cruciale pour vérifier ensuite si un nombre appartient à cette plage spécifiée.