Comment vérifier si un nombre est supérieur à un autre en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à comparer deux nombres en Java pour déterminer si l'un est supérieur à l'autre. Nous explorerons l'utilisation des opérateurs de comparaison, en particulier l'opérateur "supérieur à" (>), qui est fondamental pour prendre des décisions conditionnelles en programmation.

Grâce à des exercices pratiques, vous implémenterez du code pour lire les entrées de l'utilisateur, appliquerez l'opérateur supérieur à pour comparer différents types numériques et gérerez les cas où les nombres sont égaux. Ce laboratoire (lab) vous offrira une expérience pratique de l'utilisation des instructions conditionnelles et des opérateurs de comparaison en Java.

Utiliser l'opérateur de comparaison pour le test de supériorité

Dans cette étape, nous apprendrons à utiliser les opérateurs de comparaison en Java pour comparer deux nombres. Plus précisément, nous nous concentrerons sur l'opérateur "supérieur à" (>). Les opérateurs de comparaison sont fondamentaux en programmation car ils nous permettent de prendre des décisions en fonction de la relation entre les valeurs.

Créons un nouveau programme Java pour démontrer l'utilisation de l'opérateur "supérieur à".

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE s'il n'est pas déjà ouvert.
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 the first number: ");
        int number1 = scanner.nextInt();

        System.out.print("Enter the second number: ");
        int number2 = scanner.nextInt();

        if (number1 > number2) {
            System.out.println("The first number is greater than the second number.");
        }

        scanner.close();
    }
}
```
Examinons les nouvelles parties de ce code :
- import java.util.Scanner; : Nous avons toujours besoin de la classe Scanner pour obtenir des entrées de l'utilisateur.
- System.out.print("Enter the first number: "); : Invite l'utilisateur à saisir le premier nombre.
- int number1 = scanner.nextInt(); : Lit le premier entier saisi par l'utilisateur et le stocke dans la variable number1.
- System.out.print("Enter the second number: "); : Invite l'utilisateur à saisir le deuxième nombre.
- int number2 = scanner.nextInt(); : Lit le deuxième entier saisi par l'utilisateur et le stocke dans la variable number2.
- if (number1 > number2) : C'est ici que nous utilisons l'opérateur "supérieur à" (>). Cette ligne vérifie si la valeur de number1 est supérieure à la valeur de number2. Le code à l'intérieur des accolades {} ne s'exécutera que si cette condition est vraie.
- System.out.println("The first number is greater than the second number."); : Cette ligne sera affichée si number1 est effectivement supérieur à number2.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié dans le terminal :
```
javac HelloJava.java
```
S'il n'y a pas d'erreurs de compilation, vous ne verrez aucun message de sortie.
Exécutez le programme compilé :
```
java HelloJava
```
Le programme vous invitera à saisir deux nombres. Saisissez un nombre pour la première invitation, appuyez sur Entrée, puis saisissez un deuxième nombre et appuyez à nouveau sur Entrée.

Par exemple, si vous saisissez 10 pour le premier nombre et 5 pour le deuxième nombre, la sortie sera la suivante :
```
Enter the first number: 10
Enter the second number: 5
The first number is greater than the second number.
```
Si vous saisissez 5 pour le premier nombre et 10 pour le deuxième nombre, il n'y aura pas de sortie après avoir saisi le deuxième nombre, car la condition number1 > number2 est fausse.

Vous avez utilisé avec succès l'opérateur de comparaison "supérieur à" pour comparer deux nombres et exécuter du code en fonction du résultat.

Tester avec différents types numériques

Dans l'étape précédente, nous avons comparé deux nombres entiers. Java dispose de différents types numériques pour gérer divers types de nombres, tels que les nombres entiers (entiers) et les nombres à virgule (nombres à point flottant). Dans cette étape, nous explorerons le fonctionnement des opérateurs de comparaison avec différents types numériques.

Java a plusieurs types numériques primitifs, notamment :

int : pour les nombres entiers (entiers)
double : pour les nombres à point flottant (nombres décimaux)
float : également pour les nombres à point flottant, mais généralement moins précis que double
long : pour les très grands nombres entiers

Des opérateurs de comparaison comme > peuvent être utilisés pour comparer des valeurs de différents types numériques. Java effectuera souvent une conversion de type automatique (élargissement) pour permettre la comparaison. Par exemple, lors de la comparaison d'un int et d'un double, le int sera converti en double avant la comparaison.

Modifions notre programme pour comparer un entier et un nombre à virgule.

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

Remplacez le code existant par le 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 intNumber = scanner.nextInt();

        System.out.print("Enter a decimal number: ");
        double doubleNumber = scanner.nextDouble();

        if (intNumber > doubleNumber) {
            System.out.println("The integer is greater than the decimal number.");
        }

        if (doubleNumber > intNumber) {
            System.out.println("The decimal number is greater than the integer.");
        }

        scanner.close();
    }
}

Dans ce code mis à jour :

Nous lisons maintenant un int dans la variable intNumber en utilisant scanner.nextInt().
Nous lisons un double dans la variable doubleNumber en utilisant scanner.nextDouble().
Nous utilisons l'opérateur > pour comparer intNumber et doubleNumber. Notez que nous avons ajouté une deuxième instruction if pour vérifier si le nombre décimal est supérieur à l'entier.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme dans le terminal :
```
javac HelloJava.java
```
Exécutez le programme :
```
java HelloJava
```
Saisissez un entier et un nombre décimal lorsque vous y êtes invité.

Par exemple, si vous saisissez 10 pour l'entier et 9.5 pour le nombre décimal, la sortie sera :
```
Enter an integer: 10
Enter a decimal number: 9.5
The integer is greater than the decimal number.
```
Si vous saisissez 5 pour l'entier et 5.1 pour le nombre décimal, la sortie sera :
```
Enter an integer: 5
Enter a decimal number: 5.1
The decimal number is greater than the integer.
```

Cela démontre que Java peut comparer différents types numériques en utilisant l'opérateur "supérieur à".

Gérer les nombres égaux

Dans les étapes précédentes, nous avons utilisé l'opérateur "supérieur à" (>) pour vérifier si un nombre est plus grand qu'un autre. Cependant, que se passe-t-il si les deux nombres sont égaux ? Notre programme actuel ne gère pas explicitement ce cas.

Dans cette étape, nous apprendrons à vérifier l'égalité en utilisant l'opérateur d'égalité (==) et à utiliser les instructions if-else if-else pour gérer plusieurs possibilités, y compris lorsque les nombres sont égaux.

L'opérateur d'égalité (==) en Java est utilisé pour vérifier si deux valeurs sont égales. Il retourne true si les valeurs sont identiques et false sinon.

Modifions notre programme pour comparer deux nombres et afficher un message indiquant si le premier nombre est supérieur, inférieur ou égal au deuxième nombre.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.
Remplacez le code existant par le suivant :
```
import java.util.Scanner;

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

        System.out.print("Enter the first number: ");
        double number1 = scanner.nextDouble();

        System.out.print("Enter the second number: ");
        double number2 = scanner.nextDouble();

        if (number1 > number2) {
            System.out.println("The first number is greater than the second number.");
        } else if (number1 < number2) {
            System.out.println("The first number is less than the second number.");
        } else {
            System.out.println("The two numbers are equal.");
        }

        scanner.close();
    }
}
```
Examinons les modifications :
- Nous lisons maintenant deux valeurs de type double pour plus de flexibilité lors des tests.
- if (number1 > number2) : C'est la même vérification que précédemment. Si number1 est supérieur à number2, le premier message est affiché.
- else if (number1 < number2) : C'est une nouvelle partie. Le bloc else if est exécuté uniquement si la condition if précédente (number1 > number2) est fausse. Ici, nous utilisons l'opérateur "inférieur à" (<) pour vérifier si number1 est inférieur à number2.
- else : Ce bloc est exécuté si aucune des conditions if ou else if précédentes n'est vraie. Dans ce cas, si number1 n'est pas supérieur à number2 et n'est pas inférieur à number2, il doit être égal à number2.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme dans le terminal :
```
javac HelloJava.java
```
Exécutez le programme :
```
java HelloJava
```
Saisissez deux nombres, y compris des cas où ils sont égaux.

Si vous saisissez 7.5 pour le premier nombre et 7.5 pour le deuxième nombre, la sortie sera :
```
Enter the first number: 7.5
Enter the second number: 7.5
The two numbers are equal.
```
Si vous saisissez 10 et 5, vous verrez "The first number is greater than the second number." Si vous saisissez 5 et 10, vous verrez "The first number is less than the second number."

Vous avez maintenant utilisé avec succès les instructions if-else if-else et l'opérateur d'égalité (==) pour gérer différents résultats de comparaison, y compris l'égalité.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si un nombre est supérieur à un autre en Java. Nous avons commencé par utiliser l'opérateur de comparaison > dans une instruction if pour comparer deux valeurs entières saisies par l'utilisateur. Cela a démontré le concept fondamental de l'utilisation d'opérateurs de comparaison pour prendre des décisions dans notre code.

Nous avons ensuite exploré comment gérer différents types numériques, en nous assurant que notre logique de comparaison fonctionne correctement pour divers types de données tels que double et float. Enfin, nous avons abordé le scénario où les deux nombres sont égaux, en élargissant notre logique conditionnelle pour inclure l'opérateur "supérieur ou égal à" (>=) ou des vérifications distinctes pour l'égalité.