Comment vérifier si une expression booléenne est valide en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une expression booléenne est valide en Java. Nous commencerons par évaluer des expressions booléennes simples en utilisant des opérateurs de comparaison.

Ensuite, vous explorerez comment gérer des expressions booléennes composées en combinant des expressions simples avec des opérateurs logiques. Enfin, vous apprendrez à identifier et à capturer les erreurs qui peuvent survenir lors de la manipulation d'expressions booléennes invalides dans votre code Java.

Skills Graph

Évaluer une expression booléenne simple

Dans cette étape, nous allons apprendre les expressions booléennes en Java et comment évaluer les expressions simples. Les expressions booléennes sont fondamentales en programmation car elles nous permettent de prendre des décisions en fonction de si une condition est vraie ou fausse.

Une expression booléenne est une instruction qui s'évalue soit à true (vrai) soit à false (faux). En Java, nous utilisons des opérateurs de comparaison pour créer ces expressions. Voici quelques opérateurs de comparaison courants :

• == : Égal à
• != : Différent de
• > : Supérieur à
• < : Inférieur à
• >= : Supérieur ou égal à
• <= : Inférieur ou égal à

Créons un simple programme Java pour évaluer quelques expressions booléennes.

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

2. Remplacez tout le contenu du fichier par le code suivant :

   public class HelloJava {
       public static void main(String[] args) {
           int x = 10;
           int y = 20;
   
           boolean isEqual = (x == y);
           boolean isNotEqual = (x != y);
           boolean isGreater = (x > y);
           boolean isLess = (x < y);
           boolean isGreaterOrEqual = (x >= y);
           boolean isLessOrEqual = (x <= y);
   
           System.out.println("Is x equal to y? " + isEqual);
           System.out.println("Is x not equal to y? " + isNotEqual);
           System.out.println("Is x greater than y? " + isGreater);
           System.out.println("Is x less than y? " + isLess);
           System.out.println("Is x greater than or equal to y? " + isGreaterOrEqual);
           System.out.println("Is x less than or equal to y? " + isLessOrEqual);
       }
   }

   Dans ce code :

   • Nous déclarons deux variables entières, x et y.
   • Nous créons plusieurs variables booléennes (isEqual, isNotEqual, etc.) et assignons le résultat d'une expression booléenne à chacune.
   • Nous utilisons System.out.println pour afficher les résultats de ces expressions booléennes.

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Compilez le programme en exécutant la commande suivante dans le terminal :

   javac HelloJava.java

   S'il n'y a pas d'erreurs, un fichier HelloJava.class sera créé.

5. Exécutez le programme compilé :

   java HelloJava

   Vous devriez voir la sortie affichant les résultats de chaque expression booléenne.

   Is x equal to y? false
   Is x not equal to y? true
   Is x greater than y? false
   Is x less than y? true
   Is x greater than or equal to y? false
   Is x less than or equal to y? true

Vous avez évalué avec succès des expressions booléennes simples en Java ! Comprendre comment comparer des valeurs et obtenir un résultat true ou false est crucial pour contrôler le flux de vos programmes.

Gérer les expressions composées

Dans cette étape, nous allons apprendre à combiner des expressions booléennes simples pour créer des expressions plus complexes en utilisant des opérateurs logiques. Ces expressions sont appelées expressions composées, et elles nous permettent de vérifier plusieurs conditions à la fois.

Java propose les opérateurs logiques suivants :

• && : ET logique. L'expression est true (vraie) seulement si les deux conditions sont true.
• || : OU logique. L'expression est true si au moins une des conditions est true.
• ! : NON logique. Cet opérateur inverse la valeur booléenne d'une expression. Si une expression est true, ! la rend false, et vice versa.

Modifions notre programme HelloJava.java pour utiliser ces opérateurs logiques.

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

2. Remplacez le code actuel par le suivant :

   public class HelloJava {
       public static void main(String[] args) {
           int age = 25;
           int score = 85;
           boolean isStudent = true;
   
           // Using Logical AND (&&)
           boolean isEligibleForDiscount = (age > 18 && isStudent);
           System.out.println("Is eligible for student discount? " + isEligibleForDiscount);
   
           // Using Logical OR (||)
           boolean passedExam = (score >= 70 || age < 18);
           System.out.println("Passed the exam? " + passedExam);
   
           // Using Logical NOT (!)
           boolean isNotStudent = !isStudent;
           System.out.println("Is not a student? " + isNotStudent);
   
           // Combining multiple operators
           boolean complexCondition = (age > 20 && score > 80 || !isStudent);
           System.out.println("Complex condition result: " + complexCondition);
       }
   }

   Dans ce code mis à jour :

   • Nous introduisons de nouvelles variables age, score et isStudent.
   • Nous utilisons && pour vérifier si quelqu'un est éligible à une remise étudiante (âgé de plus de 18 ans ET est un étudiant).
   • Nous utilisons || pour vérifier si quelqu'un a réussi un examen (note de 70 ou plus OU a moins de 18 ans).
   • Nous utilisons ! pour nier la valeur booléenne de isStudent.
   • Nous montrons un exemple de combinaison de &&, || et ! dans une seule expression.

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Compilez le programme dans le terminal :

   javac HelloJava.java

   Assurez-vous qu'il n'y a pas d'erreurs de compilation.

5. Exécutez le programme compilé :

   java HelloJava

   Observez la sortie, qui montrera les résultats des expressions booléennes composées.

   Is eligible for student discount? true
   Passed the exam? true
   Is not a student? false
   Complex condition result: true

Vous avez maintenant appris à créer et évaluer des expressions booléennes composées en utilisant les opérateurs ET logique (&&), OU logique (||) et NON logique (!). Cela vous permet de construire des conditions plus sophistiquées dans vos programmes Java.

Capturer les erreurs d'expression invalide

Dans cette étape, nous allons explorer ce qui se passe lorsque nous essayons d'évaluer des expressions qui ne sont pas valides en Java et comment le compilateur nous aide à détecter ces erreurs. Comprendre les erreurs courantes est une partie importante de l'apprentissage de tout langage de programmation.

Java est un langage fortement typé, ce qui signifie que le type de données est important. Les expressions booléennes nécessitent spécifiquement des opérandes qui peuvent être comparés ou évalués en une valeur booléenne. Tenter d'utiliser des types incompatibles dans une expression booléenne entraînera une erreur de compilation.

Introduisons intentionnellement une erreur dans notre programme HelloJava.java pour voir comment le compilateur réagit.

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

2. Modifiez le code pour inclure une comparaison invalide. Par exemple, essayons de comparer un booléen avec un entier :

   public class HelloJava {
       public static void main(String[] args) {
           int age = 25;
           boolean isStudent = true;
   
           // This line will cause a compilation error
           // boolean invalidComparison = (isStudent == age);
   
           System.out.println("Age: " + age);
           System.out.println("Is student: " + isStudent);
       }
   }

   Nous avons mis en commentaire la ligne qui causera l'erreur pour l'instant, mais nous la décommenterons à l'étape suivante. La ligne mise en commentaire boolean invalidComparison = (isStudent == age); tente de comparer une variable boolean (isStudent) avec une variable int (age) en utilisant l'opérateur d'égalité (==). Java n'autorise pas cette comparaison directe car boolean et int sont des types de données différents qui ne peuvent pas être comparés de manière significative de cette façon.

3. Enregistrez le fichier (Ctrl+S ou Cmd+S).

4. Maintenant, décommentez la ligne qui causera l'erreur. Modifiez le code comme suit :

   public class HelloJava {
       public static void main(String[] args) {
           int age = 25;
           boolean isStudent = true;
   
           // This line will cause a compilation error
           boolean invalidComparison = (isStudent == age);
   
           System.out.println("Age: " + age);
           System.out.println("Is student: " + isStudent);
           System.out.println("Invalid comparison result: " + invalidComparison);
       }
   }

5. Enregistrez le fichier à nouveau.

6. Essayez de compiler le programme dans le terminal :

   javac HelloJava.java

   Vous devriez voir un message d'erreur du compilateur Java. Le message exact peut varier légèrement en fonction de la version de Java, mais il indiquera un manque de correspondance de type ou des types incompatibles.

   ~/project/HelloJava.java:7: error: incomparable types: boolean and int
           boolean invalidComparison = (isStudent == age);
                                        ^
   1 error

   Ce message d'erreur vous indique le nom du fichier (HelloJava.java), le numéro de ligne (7) et une description de l'erreur ("incomparable types: boolean and int"). C'est le compilateur qui vous aide à détecter les erreurs avant même d'essayer d'exécuter le programme.

7. Pour corriger l'erreur et rendre le programme compilable à nouveau, vous devez supprimer ou mettre en commentaire la ligne invalide. Remettez le code à la version où la ligne est mise en commentaire :

   public class HelloJava {
       public static void main(String[] args) {
           int age = 25;
           boolean isStudent = true;
   
           // This line will cause a compilation error
           // boolean invalidComparison = (isStudent == age);
   
           System.out.println("Age: " + age);
           System.out.println("Is student: " + isStudent);
       }
   }

8. Enregistrez le fichier.

9. Compilez le programme à nouveau :

   javac HelloJava.java

   Cette fois, la compilation devrait réussir et vous ne devriez pas voir de messages d'erreur.

Comprendre les erreurs de compilation et savoir les lire est une compétence cruciale pour tout programmeur. Le compilateur Java est un outil puissant qui vous aide à trouver de nombreuses erreurs courantes dès le début du processus de développement.

Résumé

Dans ce laboratoire (lab), nous avons appris les bases des expressions booléennes en Java. Nous avons commencé par comprendre ce qu'est une expression booléenne et comment elle s'évalue à true (vrai) ou false (faux). Ensuite, nous avons pratiqué l'évaluation d'expressions booléennes simples en utilisant des opérateurs de comparaison courants tels que ==, !=, >, <, >= et <=. À travers un exemple pratique, nous avons vu comment déclarer des variables entières, appliquer ces opérateurs de comparaison pour créer des expressions booléennes et afficher les valeurs booléennes résultantes.

En nous appuyant sur les expressions simples, nous avons exploré comment gérer les expressions booléennes composées en combinant des expressions simples à l'aide d'opérateurs logiques tels que && (ET), || (OU) et ! (NON). Nous avons appris comment ces opérateurs fonctionnent et comment utiliser des parenthèses pour contrôler l'ordre d'évaluation dans les expressions complexes. Enfin, nous avons souligné l'importance de gérer les erreurs potentielles qui peuvent survenir à partir d'expressions booléennes invalides, en comprenant comment identifier et résoudre les problèmes qui pourraient empêcher une expression d'être évaluée correctement.