Comment vérifier si une variable booléenne est vraie en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une variable booléenne est true en Java. Nous explorerons la méthode fondamentale utilisant l'opérateur d'égalité, plongerons dans la gestion de la classe wrapper Boolean et discuterons de la manière de gérer les valeurs null potentielles.

Grâce à des exemples pratiques, vous acquerrez une expérience concrète dans l'écriture de logique conditionnelle basée sur des valeurs booléennes, garantissant que votre code Java est robuste et gère efficacement différents scénarios.

Utiliser l'opérateur d'égalité pour vérifier la valeur vraie

Dans cette étape, nous allons explorer comment vérifier si une variable booléenne est true en Java en utilisant l'opérateur d'égalité. Bien que cela puisse sembler simple, il est important de comprendre les subtilités pour écrire un code propre et correct.

En Java, le type de données boolean peut prendre l'une des deux valeurs suivantes : true ou false. Lorsque vous avez une variable booléenne, vous devez souvent vérifier sa valeur pour prendre des décisions dans votre programme.

La façon la plus courante de vérifier si une variable booléenne est true consiste à utiliser l'opérateur d'égalité ==.

Créons un simple programme Java pour illustrer cela.

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 :
```
public class HelloJava {
    public static void main(String[] args) {
        boolean isJavaFun = true;

        if (isJavaFun == true) {
            System.out.println("Java is fun!");
        } else {
            System.out.println("Java is not fun.");
        }
    }
}
```
Examinons les nouvelles parties de ce code :
- boolean isJavaFun = true; : Cette ligne déclare une variable booléenne nommée isJavaFun et l'initialise avec la valeur true.
- if (isJavaFun == true) : Il s'agit d'une instruction if. Elle vérifie si la condition entre parenthèses est true. La condition isJavaFun == true utilise l'opérateur d'égalité == pour comparer la valeur de la variable isJavaFun avec le littéral booléen true.
- System.out.println("Java is fun!"); : Cette ligne sera exécutée si la condition isJavaFun == true est true.
- else : Ce mot-clé introduit le bloc de code à exécuter si la condition de l'instruction if est false.
- System.out.println("Java is not fun."); : Cette ligne sera exécutée si la condition isJavaFun == true est false.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme en utilisant la commande javac dans le terminal :
```
javac HelloJava.java
```
S'il n'y a pas d'erreurs, un fichier HelloJava.class sera créé dans le répertoire ~/project.
Exécutez le programme compilé en utilisant la commande java :
```
java HelloJava
```
Vous devriez voir la sortie suivante :
```
Java is fun!
```
Cela confirme que la condition de l'instruction if isJavaFun == true s'est évaluée à true, et le message correspondant a été affiché.

Bien que l'utilisation de == true soit parfaitement valide et facile à comprendre, en Java, vous pouvez simplifier la vérification de true. Étant donné que l'instruction if évalue déjà l'expression entre parenthèses comme un booléen, vous pouvez directement utiliser la variable booléenne elle-même comme condition.

Modifions le code pour utiliser cette approche simplifiée :

Ouvrez à nouveau HelloJava.java dans l'éditeur.
Changez l'instruction if comme suit :
```
if (isJavaFun) {
    System.out.println("Java is fun!");
} else {
    System.out.println("Java is not fun.");
}
```
Notez que nous avons supprimé == true. L'instruction if (isJavaFun) est équivalente à if (isJavaFun == true).
Enregistrez le fichier.
Compilez le programme modifié :
```
javac HelloJava.java
```
Exécutez le programme à nouveau :
```
java HelloJava
```
Vous obtiendrez la même sortie :
```
Java is fun!
```
Cela démontre que l'utilisation directe de la variable booléenne dans la condition de l'instruction if est une façon plus concise et idiomatique de vérifier si elle est true.

En résumé, vous pouvez utiliser l'opérateur d'égalité == true pour vérifier si un booléen est vrai, mais la façon la plus courante et la plus propre consiste simplement à utiliser la variable booléenne elle-même comme condition dans une instruction if.

Tester avec la classe wrapper Boolean

Dans l'étape précédente, nous avons travaillé avec le type primitif boolean. Java dispose également d'une classe wrapper correspondante appelée Boolean. Les classes wrapper offrent un moyen d'utiliser les types de données primitifs sous forme d'objets. Cela est particulièrement utile lorsqu'on travaille avec des collections ou lorsqu'il est nécessaire de représenter une valeur booléenne qui peut être null.

La classe Boolean possède deux objets prédéfinis pour les valeurs booléennes : Boolean.TRUE et Boolean.FALSE. Ce sont des objets constants représentant respectivement les valeurs booléennes true et false.

Lorsqu'on travaille avec des objets Boolean, on peut toujours utiliser l'opérateur d'égalité == pour les comparer. Cependant, il est important de comprendre le fonctionnement de == avec les objets. Pour les objets, == vérifie si les deux variables font référence au même objet exact en mémoire, et non seulement si elles ont la même valeur.

Modifions notre programme pour utiliser la classe wrapper Boolean et observons le comportement de l'opérateur d'égalité.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.
Remplacez le code par le suivant :
```
public class HelloJava {
    public static void main(String[] args) {
        Boolean isJavaFunObject = Boolean.TRUE;

        if (isJavaFunObject == Boolean.TRUE) {
            System.out.println("Java is fun (using Boolean.TRUE)!");
        } else {
            System.out.println("Java is not fun (using Boolean.TRUE).");
        }

        Boolean anotherBooleanObject = true; // Autoboxing

        if (anotherBooleanObject == Boolean.TRUE) {
             System.out.println("Another boolean object is true!");
        } else {
             System.out.println("Another boolean object is not true.");
        }
    }
}
```
Examinons les modifications :
- Boolean isJavaFunObject = Boolean.TRUE; : Nous déclarons une variable de type Boolean et lui assignons la constante Boolean.TRUE.
- if (isJavaFunObject == Boolean.TRUE) : Nous utilisons l'opérateur d'égalité == pour comparer notre objet Boolean avec la constante Boolean.TRUE. Étant donné que isJavaFunObject est assigné à Boolean.TRUE, ils font référence au même objet, donc cette condition sera true.
- Boolean anotherBooleanObject = true; : Cette ligne illustre l'"autoboxing". Java convertit automatiquement la valeur primitive boolean true en un objet Boolean.
- if (anotherBooleanObject == Boolean.TRUE) : Nous utilisons à nouveau == pour comparer anotherBooleanObject avec Boolean.TRUE. En raison du fonctionnement de l'autoboxing et de la mise en cache des valeurs Boolean par Java, pour les valeurs true et false, les objets Boolean autoboxés font souvent référence aux mêmes instances mises en cache que Boolean.TRUE et Boolean.FALSE. Par conséquent, cette condition sera également probablement true.
Enregistrez le fichier.
Compilez le programme :
```
javac HelloJava.java
```
Exécutez le programme :
```
java HelloJava
```
Vous devriez voir la sortie suivante :
```
Java is fun (using Boolean.TRUE)!
Another boolean object is true!
```
Cela confirme que l'utilisation de == avec Boolean.TRUE fonctionne comme prévu dans ces cas car les variables font probablement référence au même objet Boolean.TRUE sous - jacent.

Cependant, compter sur == pour comparer des objets Boolean peut être risqué dans des scénarios plus complexes, en particulier si les objets Boolean sont créés de différentes manières ou proviennent de différentes sources. Une façon plus sûre et recommandée de comparer des objets Boolean pour l'égalité de valeur est d'utiliser la méthode .equals().

Modifions le code pour utiliser .equals().

Ouvrez HelloJava.java dans l'éditeur.

Changez les instructions if pour utiliser .equals() :

public class HelloJava {
    public static void main(String[] args) {
        Boolean isJavaFunObject = Boolean.TRUE;

        if (isJavaFunObject.equals(Boolean.TRUE)) {
            System.out.println("Java is fun (using equals)!");
        } else {
            System.out.println("Java is not fun (using equals).");
        }

        Boolean anotherBooleanObject = true; // Autoboxing

        if (anotherBooleanObject.equals(Boolean.TRUE)) {
             System.out.println("Another boolean object is true (using equals)!");
        } else {
             System.out.println("Another boolean object is not true (using equals).");
        }
    }
}

Nous avons remplacé == Boolean.TRUE par .equals(Boolean.TRUE). La méthode .equals() compare la valeur des objets, et non leur emplacement en mémoire.

Enregistrez le fichier.
Compilez le programme :
```
javac HelloJava.java
```
Exécutez le programme :
```
java HelloJava
```
Vous devriez voir la sortie suivante :
```
Java is fun (using equals)!
Another boolean object is true (using equals)!
```
L'utilisation de .equals() est la façon standard et la plus sûre de comparer des objets Boolean pour l'égalité de valeur.

En résumé, bien que == puisse fonctionner pour comparer des objets Boolean avec Boolean.TRUE en raison de la mise en cache, la méthode .equals() est la façon préférée et plus fiable de vérifier si un objet Boolean représente la valeur true.

Gérer les valeurs booléennes nulles

Dans l'étape précédente, nous avons appris à connaître la classe wrapper Boolean. Une différence clé entre le type primitif boolean et la classe wrapper Boolean est qu'une variable de type Boolean peut avoir la valeur null, tandis qu'un boolean primitif ne peut pas. Gérer les valeurs null est crucial en Java pour éviter les erreurs de type NullPointerException.

Une NullPointerException se produit lorsque vous essayez d'utiliser une variable qui pointe actuellement vers null comme si c'était un objet valide. Par exemple, appeler une méthode sur un objet null entraînera une NullPointerException.

Lorsque vous vérifiez si un objet Boolean est true, vous devez faire attention si l'objet peut être null.

Voyons ce qui se passe si nous essayons de vérifier un objet Boolean null en utilisant les méthodes que nous avons apprises jusqu'à présent.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.
Remplacez le code par le suivant :
```
public class HelloJava {
    public static void main(String[] args) {
        Boolean nullableBoolean = null;

        // Attempting to use == with null
        if (nullableBoolean == true) {
            System.out.println("This won't be printed.");
        } else {
            System.out.println("Using == with null Boolean.");
        }

        // Attempting to use .equals() with null
        // This will cause a NullPointerException!
        // if (nullableBoolean.equals(Boolean.TRUE)) {
        //     System.out.println("This will not be reached.");
        // } else {
        //     System.out.println("This will not be reached either.");
        // }
    }
}
```
Dans ce code :
- Boolean nullableBoolean = null; : Nous déclarons une variable de type Boolean et la définissons explicitement sur null.
- if (nullableBoolean == true) : Nous utilisons l'opérateur d'égalité == pour comparer l'objet Boolean null avec la valeur primitive true. Lorsque vous comparez un objet Boolean (même s'il est null) avec un boolean primitif, Java effectue un "unboxing". Il essaie de convertir l'objet Boolean en un boolean primitif. Si l'objet Boolean est null, ce processus d'unboxing entraîne une NullPointerException.
- La vérification .equals() mise en commentaire entraînerait également une NullPointerException car vous essayez d'appeler la méthode .equals() sur un objet null (nullableBoolean).
Enregistrez le fichier.
Compilez le programme :
```
javac HelloJava.java
```
Exécutez le programme :
```
java HelloJava
```
Vous verrez un message d'erreur dans le terminal, indiquant une NullPointerException :
```
Exception in thread "main" java.lang.NullPointerException
    at HelloJava.main(HelloJava.java:6)
```
Cela montre que comparer directement un objet Boolean potentiellement null avec un boolean primitif en utilisant == ou en appelant .equals() sur celui-ci peut entraîner une NullPointerException.

Pour gérer en toute sécurité les objets Boolean potentiellement null, vous devez toujours vérifier si l'objet est null avant d'essayer de le déballer (unboxing) ou d'appeler des méthodes sur celui-ci.

Voici comment vous pouvez vérifier en toute sécurité si un objet Boolean est true :

Ouvrez HelloJava.java dans l'éditeur.

Remplacez le code par le suivant :

public class HelloJava {
    public static void main(String[] args) {
        Boolean nullableBoolean = null;
        Boolean trueBoolean = Boolean.TRUE;
        Boolean falseBoolean = Boolean.FALSE;

        // Safely check if nullableBoolean is true
        if (nullableBoolean != null && nullableBoolean == true) {
            System.out.println("nullableBoolean is true (safe check).");
        } else {
            System.out.println("nullableBoolean is not true or is null (safe check).");
        }

        // Safely check if trueBoolean is true
        if (trueBoolean != null && trueBoolean == true) {
            System.out.println("trueBoolean is true (safe check).");
        } else {
            System.out.println("trueBoolean is not true or is null (safe check).");
        }

        // Safely check if falseBoolean is true
        if (falseBoolean != null && falseBoolean == true) {
            System.out.println("falseBoolean is true (safe check).");
        } else {
            System.out.println("falseBoolean is not true or is null (safe check).");
        }

        // Alternative safe check using equals
        if (Boolean.TRUE.equals(nullableBoolean)) {
             System.out.println("nullableBoolean is true (safe equals check).");
        } else {
             System.out.println("nullableBoolean is not true or is null (safe equals check).");
        }

         if (Boolean.TRUE.equals(trueBoolean)) {
             System.out.println("trueBoolean is true (safe equals check).");
         } else {
             System.out.println("trueBoolean is not true or is null (safe equals check).");
         }
    }
}

Dans ce code mis à jour :

if (nullableBoolean != null && nullableBoolean == true) : Nous vérifions d'abord si nullableBoolean n'est pas null en utilisant nullableBoolean != null. L'opérateur && signifie que la deuxième partie de la condition (nullableBoolean == true) ne sera évaluée que si la première partie (nullableBoolean != null) est true. Cela empêche la NullPointerException. Si nullableBoolean est null, la première partie est false, et toute la condition est false sans évaluer la deuxième partie.
if (Boolean.TRUE.equals(nullableBoolean)) : C'est une autre façon sûre de vérifier si un objet Boolean est true, même s'il est null. En appelant .equals() sur l'objet non null connu Boolean.TRUE et en passant l'objet potentiellement null nullableBoolean comme argument, nous évitons la NullPointerException. La méthode .equals() est conçue pour gérer les arguments null de manière appropriée ; Boolean.TRUE.equals(null) retournera simplement false.

Enregistrez le fichier.
Compilez le programme :
```
javac HelloJava.java
```
Exécutez le programme :
```
java HelloJava
```
Vous devriez voir la sortie suivante :
```
nullableBoolean is not true or is null (safe check).
trueBoolean is true (safe check).
falseBoolean is not true or is null (safe check).
nullableBoolean is not true or is null (safe equals check).
trueBoolean is true (safe equals check).
```
Cela démontre comment vérifier en toute sécurité la valeur d'un objet Boolean, même lorsqu'il peut être null, en utilisant à la fois la vérification != null combinée avec == true et la méthode Boolean.TRUE.equals().

N'oubliez jamais de prendre en compte la possibilité d'une valeur null lorsque vous travaillez avec des objets Boolean pour éviter les erreurs d'exécution.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si une variable booléenne est true en Java. Nous avons commencé par utiliser l'opérateur d'égalité == pour comparer directement une variable booléenne avec le littéral booléen true. C'est la méthode la plus courante et la plus directe pour vérifier la valeur d'un booléen primitif.

Nous avons également exploré comment gérer les objets wrapper Boolean, qui peuvent être null. Nous avons appris que comparer directement un objet Boolean avec true en utilisant == peut ne pas fonctionner comme prévu en raison de l'identité des objets. Au lieu de cela, nous devrions utiliser la méthode equals() ou déballer (unboxing) l'objet Boolean en sa valeur booléenne primitive avant la comparaison. Enfin, nous avons souligné l'importance de gérer les potentielles NullPointerException lors de la manipulation d'objets Boolean pouvant être null en vérifiant la valeur null avant d'essayer d'accéder à leur valeur.