Comment vérifier si un nombre est positif en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un nombre est positif en Java. Nous commencerons par écrire un programme simple pour comparer un nombre à zéro en utilisant des instructions conditionnelles de base.

Vous étendrez ensuite vos connaissances pour tester avec les types de données entier (integer) et double, en comprenant comment gérer différentes représentations numériques. Enfin, nous explorerons comment gérer les cas limites (edge cases), en nous concentrant particulièrement sur la façon d'identifier et de gérer correctement le cas où le nombre est zéro.

Comparer un nombre à zéro

Dans cette étape, nous allons écrire un simple programme Java pour comparer un nombre à zéro. Cela vous familiarisera avec les instructions conditionnelles de base en Java, en particulier l'instruction if. Les instructions conditionnelles permettent à votre programme de prendre des décisions en fonction de certaines conditions.

Tout d'abord, assurez-vous d'être dans le bon répertoire. Ouvrez le Terminal en bas de l'WebIDE et tapez la commande suivante, puis appuyez sur Entrée :
```
cd ~/project
```
Cela vous assure que vous êtes dans le répertoire ~/project où nous allons créer notre fichier Java.
Maintenant, créons un nouveau fichier Java nommé CompareNumber.java. Vous pouvez le faire en cliquant avec le bouton droit dans l'Explorateur de fichiers à gauche, en sélectionnant "Nouveau fichier" et en tapant CompareNumber.java. Alternativement, vous pouvez utiliser le Terminal :
```
touch CompareNumber.java
```
Ouvrez le fichier CompareNumber.java dans l'Éditeur de code en cliquant dessus dans l'Explorateur de fichiers.
Copiez et collez le code Java suivant dans l'éditeur :
```
public class CompareNumber {
    public static void main(String[] args) {
        int number = 10; // Nous allons comparer ce nombre à zéro

        if (number > 0) {
            System.out.println("The number is positive.");
        }
    }
}
```
Examinons les nouvelles parties de ce code :
- int number = 10; : Cette ligne déclare une variable nommée number de type int (entier) et lui assigne la valeur 10. Les variables sont utilisées pour stocker des données dans votre programme.
- if (number > 0) : Il s'agit d'une instruction if. Elle vérifie si la condition entre parenthèses (number > 0) est vraie. Si la condition est vraie, le code entre accolades {} qui suit sera exécuté.
- System.out.println("The number is positive."); : Cette ligne ne sera exécutée que si le number est supérieur à 0.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Maintenant, compilez le programme Java en utilisant la commande javac dans le Terminal :
```
javac CompareNumber.java
```
S'il n'y a pas d'erreurs, un fichier CompareNumber.class sera créé dans le répertoire ~/project.
Enfin, exécutez le programme compilé en utilisant la commande java :
```
java CompareNumber
```
Étant donné que la variable number est définie sur 10 (qui est supérieur à 0), vous devriez voir la sortie suivante :
```
The number is positive.
```

Vous avez réussi à écrire et à exécuter un programme Java qui utilise une instruction if pour comparer un nombre à zéro. Dans l'étape suivante, nous allons étendre ce programme pour gérer différents cas.

Tester avec des entiers (Integer) et des décimaux (Double)

Dans l'étape précédente, nous avons comparé un entier à zéro. Java prend en charge différents types de nombres, notamment les entiers (nombres entiers) et les nombres à virgule flottante (nombres avec des décimales). Dans cette étape, nous allons modifier notre programme pour tester avec les types de données entier (integer) et double, et introduire l'instruction else pour gérer le cas où le nombre n'est pas positif.

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

Modifiez le code pour inclure un bloc else. Remplacez le code existant par le suivant :

public class CompareNumber {
    public static void main(String[] args) {
        int number = -5; // Testons avec un entier négatif

        if (number > 0) {
            System.out.println("The number is positive.");
        } else {
            System.out.println("The number is not positive.");
        }
    }
}

Voici ce qui est nouveau :

- `int number = -5;` : Nous avons changé la valeur de `number` en -5 pour tester la condition `else`.
- `else { ... }` : Le bloc `else` est exécuté si la condition dans l'instruction `if` précédente est fausse. Dans ce cas, si `number > 0` est faux, le code à l'intérieur du bloc `else` sera exécuté.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié dans le Terminal :
```
javac CompareNumber.java
```
Exécutez le programme compilé :
```
java CompareNumber
```
Étant donné que number vaut -5, la condition if (-5 > 0) est fausse, donc le bloc else sera exécuté. Vous devriez voir la sortie suivante :
```
The number is not positive.
```

Maintenant, testons avec un double (un nombre à virgule flottante). Modifiez le code à nouveau :

public class CompareNumber {
    public static void main(String[] args) {
        double decimalNumber = 3.14; // Testons avec un double positif

        if (decimalNumber > 0) {
            System.out.println("The number is positive.");
        } else {
            System.out.println("The number is not positive.");
        }
    }
}

Nous avons changé le type de la variable en double et lui avons assigné une valeur décimale.

Enregistrez le fichier.
Compilez le programme :
```
javac CompareNumber.java
```
Exécutez le programme :
```
java CompareNumber
```
Étant donné que decimalNumber vaut 3.14 (qui est supérieur à 0), la condition if sera vraie, et vous devriez voir la sortie suivante :
```
The number is positive.
```

Vous avez maintenant vu comment utiliser l'instruction else et comment la comparaison fonctionne avec les types de données entier et double. Dans l'étape suivante, nous allons gérer le cas spécifique où le nombre est exactement zéro.

Gérer les cas limites comme zéro

Dans les étapes précédentes, nous avons traité les nombres positifs et non positifs. Cependant, nous n'avons pas spécifiquement abordé le cas où le nombre est exactement zéro. En programmation, gérer ces "cas limites" est important pour garantir que votre programme se comporte correctement dans toutes les situations. Dans cette étape, nous allons utiliser l'instruction else if pour ajouter une vérification spécifique pour zéro.

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

Modifiez le code pour inclure un bloc else if afin de vérifier si le nombre est zéro. Remplacez le code existant par le suivant :

public class CompareNumber {
    public static void main(String[] args) {
        int number = 0; // Testons avec zéro

        if (number > 0) {
            System.out.println("The number is positive.");
        } else if (number == 0) {
            System.out.println("The number is zero.");
        } else {
            System.out.println("The number is negative.");
        }
    }
}

Examinons les modifications :

- `int number = 0;` : Nous avons défini `number` à 0 pour tester la nouvelle condition.
- `else if (number == 0)` : Il s'agit d'une instruction `else if`. Elle est vérifiée uniquement si la condition `if` précédente (`number > 0`) est fausse. La condition `number == 0` vérifie si la valeur de `number` est exactement égale à 0. Notez le double signe égal (`==`) pour la comparaison, car un seul signe égal (`=`) est utilisé pour l'affectation.
- `System.out.println("The number is zero.");` : Cette ligne sera exécutée si `number` est exactement 0.
- Le bloc `else` final gère maintenant spécifiquement le cas où le nombre n'est ni positif ni zéro, ce qui signifie qu'il doit être négatif.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié dans le Terminal :
```
javac CompareNumber.java
```
Exécutez le programme compilé :
```
java CompareNumber
```
Étant donné que number vaut 0, la première condition if (0 > 0) est fausse. La condition else if (0 == 0) est vraie, donc son bloc sera exécuté. Vous devriez voir la sortie suivante :
```
The number is zero.
```

Maintenant, testons à nouveau avec un nombre négatif. Changez la valeur de number en -10 :

public class CompareNumber {
    public static void main(String[] args) {
        int number = -10; // Testons avec un nombre négatif

        if (number > 0) {
            System.out.println("The number is positive.");
        } else if (number == 0) {
            System.out.println("The number is zero.");
        } else {
            System.out.println("The number is negative.");
        }
    }
}

Enregistrez le fichier.
Compilez le programme :
```
javac CompareNumber.java
```
Exécutez le programme :
```
java CompareNumber
```
Étant donné que number vaut -10, la condition if (-10 > 0) est fausse, et la condition else if (-10 == 0) est également fausse. Par conséquent, le bloc else final sera exécuté, et vous devriez voir la sortie suivante :
```
The number is negative.
```

Vous avez maintenant utilisé avec succès les instructions if, else if et else pour comparer un nombre à zéro et déterminer s'il est positif, négatif ou zéro. Ceci est un modèle fondamental pour prendre des décisions dans vos programmes Java.

Résumé

Dans ce laboratoire (lab), nous avons commencé par apprendre à configurer notre environnement de développement en accédant au bon répertoire et en créant un nouveau fichier Java. Nous avons ensuite introduit le concept fondamental des instructions conditionnelles en Java en utilisant l'instruction if. En écrivant un programme simple, nous avons appris à déclarer une variable entière, lui assigner une valeur et utiliser l'opérateur > dans une condition if pour vérifier si le nombre est supérieur à zéro. Nous avons vu comment le bloc de code à l'intérieur de l'instruction if n'est exécuté que lorsque la condition est vraie, ce qui démontre comment afficher un message indiquant que le nombre est positif.