Comment vérifier si une condition est vraie en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une condition est vraie en Java en utilisant des expressions conditionnelles. Ce concept de programmation fondamental permet à vos programmes de prendre des décisions et de se comporter différemment en fonction de diverses situations. Vous commencerez par écrire une simple expression conditionnelle en utilisant une instruction if pour exécuter du code uniquement lorsqu'une condition spécifique est remplie.

En vous appuyant sur les bases, vous explorerez ensuite comment tester des conditions à l'aide de variables, rendant vos programmes plus dynamiques. Enfin, vous apprendrez à gérer des conditions plus complexes, permettant à vos applications Java de prendre des décisions sophistiquées.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java/BasicSyntaxGroup -.-> java/operators("Operators") java/BasicSyntaxGroup -.-> java/booleans("Booleans") java/BasicSyntaxGroup -.-> java/variables("Variables") java/BasicSyntaxGroup -.-> java/if_else("If...Else") java/BasicSyntaxGroup -.-> java/output("Output") subgraph Lab Skills java/operators -.-> lab-559943{{"Comment vérifier si une condition est vraie en Java"}} java/booleans -.-> lab-559943{{"Comment vérifier si une condition est vraie en Java"}} java/variables -.-> lab-559943{{"Comment vérifier si une condition est vraie en Java"}} java/if_else -.-> lab-559943{{"Comment vérifier si une condition est vraie en Java"}} java/output -.-> lab-559943{{"Comment vérifier si une condition est vraie en Java"}} end

Écrire une expression conditionnelle simple

Dans cette étape, nous allons apprendre les expressions conditionnelles en Java. Les expressions conditionnelles permettent à votre programme de prendre des décisions en fonction de certaines conditions. C'est un concept fondamental en programmation, qui permet à vos programmes de se comporter différemment en fonction de la situation.

Imaginez-le comme ceci : "SI il pleut, ALORS prenez un parapluie." La condition est "il pleut", et l'action est "prendre un parapluie". En Java, nous utilisons les instructions if pour y parvenir.

Commençons par créer un nouveau fichier Java.

Ouvrez l'Explorateur de fichiers sur le côté gauche de l'IDE Web.
Cliquez avec le bouton droit dans le répertoire ~/project et sélectionnez "Nouveau fichier".
Nommez le nouveau fichier ConditionalExample.java.

Maintenant, écrivons un peu de code dans ce fichier. Copiez et collez le code suivant dans le fichier ConditionalExample.java :

public class ConditionalExample {
    public static void main(String[] args) {
        int number = 10;

        if (number > 5) {
            System.out.println("The number is greater than 5.");
        }
    }
}

Décortiquons ce code :

public class ConditionalExample : Cela déclare notre classe, qui correspond au nom du fichier.
public static void main(String[] args) : C'est la méthode principale où notre programme commence son exécution.
int number = 10; : Cela déclare une variable entière nommée number et lui assigne la valeur 10.
if (number > 5) : C'est l'instruction if. La condition est number > 5. Le code à l'intérieur des accolades {} ne sera exécuté que si cette condition est vraie.
System.out.println("The number is greater than 5."); : Cette ligne affichera le message dans la console si la condition number > 5 est vraie.

Étant donné que number vaut 10, et que 10 est bien supérieur à 5, la condition number > 5 est vraie. Par conséquent, le message "The number is greater than 5." devrait être affiché.

Enregistrez le fichier ConditionalExample.java (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 fichier Java en utilisant la commande javac :
```
javac ConditionalExample.java
```
S'il n'y a pas d'erreurs, cette commande créera un fichier ConditionalExample.class.
Exécutez le programme Java compilé en utilisant la commande java :
```
java ConditionalExample
```

Vous devriez voir la sortie suivante :

The number is greater than 5.

Cela confirme que notre simple expression conditionnelle a fonctionné comme prévu. Dans l'étape suivante, nous explorerons comment utiliser des variables dans nos conditions.

Tester une condition avec des variables

Dans cette étape, nous approfondirons notre compréhension des expressions conditionnelles en utilisant des variables dans les conditions. Cela rend nos programmes plus dynamiques, car le résultat peut changer en fonction des valeurs stockées dans les variables.

Modifions le fichier ConditionalExample.java que nous avons créé à l'étape précédente.

Ouvrez le fichier ConditionalExample.java dans l'éditeur de l'IDE Web.
Remplacez le code existant par le suivant :

public class ConditionalExample {
    public static void main(String[] args) {
        int temperature = 25;
        boolean isSunny = true;

        if (temperature > 20) {
            System.out.println("It's a warm day.");
        }

        if (isSunny) {
            System.out.println("It's sunny today.");
        }
    }
}

Dans ce code mis à jour :

Nous avons deux variables : temperature (un entier) et isSunny (un booléen, qui peut être true ou false).
La première instruction if vérifie si la variable temperature est supérieure à 20.
La deuxième instruction if vérifie si la variable isSunny est true.

Étant donné que temperature vaut 25 (ce qui est supérieur à 20) et que isSunny est true, les deux conditions devraient être évaluées comme vraies, et les deux messages devraient être affichés.

Enregistrez le fichier ConditionalExample.java.
Ouvrez le Terminal et assurez-vous que vous êtes dans le répertoire ~/project.
Compilez le fichier Java modifié :
```
javac ConditionalExample.java
```
Exécutez le programme compilé :
```
java ConditionalExample
```

Vous devriez voir la sortie suivante :

It's a warm day.
It's sunny today.

Cela montre comment vous pouvez utiliser directement des variables dans vos conditions if. La sortie du programme change en fonction des valeurs actuelles des variables temperature et isSunny.

Maintenant, modifions les valeurs des variables pour voir comment la sortie change.

Modifiez à nouveau le fichier ConditionalExample.java. Changez les valeurs des variables :

public class ConditionalExample {
    public static void main(String[] args) {
        int temperature = 15; // Changed temperature
        boolean isSunny = false; // Changed isSunny

        if (temperature > 20) {
            System.out.println("It's a warm day.");
        }

        if (isSunny) {
            System.out.println("It's sunny today.");
        }
    }
}

Enregistrez le fichier.
Compilez le programme à nouveau :
```
javac ConditionalExample.java
```
Exécutez le programme :
```
java ConditionalExample
```

Cette fois-ci, puisque temperature vaut 15 (pas supérieur à 20) et que isSunny est false, aucune des conditions n'est vraie, et vous ne devriez voir aucune sortie.

Cela illustre la puissance de l'utilisation de variables dans les instructions conditionnelles – le comportement du programme est déterminé par les données qu'il traite.

Gérer des conditions complexes

Dans cette étape, nous allons apprendre à combiner plusieurs conditions pour créer une logique de prise de décision plus complexe dans nos programmes Java. Nous pouvons utiliser des opérateurs logiques tels que && (ET) et || (OU) pour y parvenir.

Modifions une dernière fois le fichier ConditionalExample.java.

Ouvrez le fichier ConditionalExample.java dans l'éditeur de l'IDE Web.
Remplacez le code existant par le suivant :

public class ConditionalExample {
    public static void main(String[] args) {
        int temperature = 25;
        boolean isSunny = true;
        boolean isWeekend = false;

        // Condition using AND (&&)
        if (temperature > 20 && isSunny) {
            System.out.println("It's a warm and sunny day.");
        }

        // Condition using OR (||)
        if (isSunny || isWeekend) {
            System.out.println("It's either sunny or the weekend.");
        }

        // Condition using AND and OR
        if ((temperature > 25 && isSunny) || isWeekend) {
             System.out.println("It's very warm and sunny, or it's the weekend.");
        }
    }
}

Examinons les nouvelles parties :

boolean isWeekend = false; : Nous avons ajouté une nouvelle variable booléenne isWeekend.
if (temperature > 20 && isSunny) : Cette condition utilise l'opérateur && (ET). Le code à l'intérieur des accolades ne sera exécuté que si les deux conditions temperature > 20 et isSunny sont vraies.
if (isSunny || isWeekend) : Cette condition utilise l'opérateur || (OU). Le code à l'intérieur des accolades sera exécuté si l'une des conditions isSunny ou isWeekend est vraie (ou les deux).
if ((temperature > 25 && isSunny) || isWeekend) : Cette condition combine les opérateurs && et ||. Les parenthèses () sont utilisées pour regrouper les conditions, tout comme en mathématiques. Cette condition est vraie si (temperature > 25 ET isSunny) est vraie, OU si isWeekend est vraie.

Compte tenu des valeurs actuelles des variables (temperature = 25, isSunny = true, isWeekend = false) :

temperature > 20 && isSunny : (25 > 20) est vrai, isSunny est vrai. Vrai && Vrai est Vrai. Cette condition est vraie.
isSunny || isWeekend : isSunny est vrai, isWeekend est faux. Vrai || Faux est Vrai. Cette condition est vraie.
(temperature > 25 && isSunny) || isWeekend : (25 > 25) est faux, isSunny est vrai. Faux && Vrai est Faux. Faux || Faux est Faux. Cette condition est fausse.

Donc, nous nous attendons à ce que les deux premiers messages soient affichés, mais pas le troisième.

Enregistrez le fichier ConditionalExample.java.
Ouvrez le Terminal et assurez-vous que vous êtes dans le répertoire ~/project.
Compilez le fichier Java modifié :
```
javac ConditionalExample.java
```
Exécutez le programme compilé :
```
java ConditionalExample
```

Vous devriez voir la sortie suivante :

It's a warm and sunny day.
It's either sunny or the weekend.

Cela confirme que nos conditions complexes utilisant && et || ont fonctionné correctement. Vous pouvez modifier les valeurs de temperature, isSunny et isWeekend, recompiler et exécuter le programme pour voir comment la sortie change en fonction des différentes combinaisons de conditions.

Comprendre comment combiner des conditions est crucial pour écrire des programmes capables de gérer diverses situations et de prendre des décisions plus sophistiquées.

Résumé

Dans ce laboratoire, nous avons commencé par apprendre le concept fondamental des expressions conditionnelles en Java, qui permettent aux programmes de prendre des décisions en fonction de conditions. Nous avons créé un simple fichier Java nommé ConditionalExample.java et écrit du code démontrant une instruction if de base. Cela a impliqué la déclaration d'une variable entière et l'utilisation d'une instruction if avec une condition (number > 5) pour contrôler l'exécution d'une instruction d'impression. Nous avons appris que le code à l'intérieur du bloc if n'est exécuté que lorsque la condition spécifiée est évaluée comme vraie.

Nous avons ensuite testé des conditions en utilisant des variables, en nous appuyant sur l'instruction if de base. Cela a consisté à utiliser des variables dans l'expression conditionnelle pour rendre le processus de prise de décision dynamique. Enfin, nous avons exploré la gestion de conditions complexes, ce qui a probablement impliqué la combinaison de plusieurs conditions à l'aide d'opérateurs logiques (comme && pour ET, || pour OU et ! pour NON) pour créer une logique de prise de décision plus sophistiquée dans nos programmes Java.