Wie man prüft, ob eine boolesche Variable in Java true ist

Einführung

In diesem Lab lernen Sie, wie Sie in Java prüfen können, ob eine boolesche Variable true ist. Wir werden die grundlegende Methode mithilfe des Gleichheitsoperators untersuchen, uns mit der Behandlung der Boolean-Wrapper-Klasse befassen und besprechen, wie Sie potenzielle Nullwerte verwalten können.

Durch praktische Beispiele gewinnen Sie praktische Erfahrung beim Schreiben von bedingter Logik basierend auf booleschen Werten, um sicherzustellen, dass Ihr Java-Code robust ist und verschiedene Szenarien effektiv behandelt.

Skills Graph

Verwendung des Gleichheitsoperators für die Prüfung auf "true"

In diesem Schritt werden wir untersuchen, wie Sie in Java mithilfe des Gleichheitsoperators prüfen können, ob eine boolesche Variable true ist. Auch wenn dies auf den ersten Blick einfach erscheint, ist es wichtig, die Feinheiten zu verstehen, um sauberen und korrekten Code zu schreiben.

In Java kann der boolean-Datentyp einen von zwei Werten annehmen: true oder false. Wenn Sie eine boolesche Variable haben, müssen Sie oft ihren Wert prüfen, um Entscheidungen in Ihrem Programm zu treffen.

Der gebräuchlichste Weg, um zu prüfen, ob eine boolesche Variable true ist, ist die Verwendung des Gleichheitsoperators ==.

Erstellen wir ein einfaches Java-Programm, um dies zu demonstrieren.

1. Öffnen Sie die Datei HelloJava.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.

2. Ersetzen Sie den gesamten Inhalt der Datei durch folgenden Code:

   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.");
           }
       }
   }

   Schauen wir uns die neuen Teile dieses Codes an:

   • boolean isJavaFun = true;: Diese Zeile deklariert eine boolesche Variable namens isJavaFun und initialisiert sie mit dem Wert true.
   • if (isJavaFun == true): Dies ist eine if-Anweisung. Sie prüft, ob die Bedingung in den Klammern true ist. Die Bedingung isJavaFun == true verwendet den Gleichheitsoperator ==, um den Wert der Variable isJavaFun mit dem booleschen Literal true zu vergleichen.
   • System.out.println("Java is fun!");: Diese Zeile wird ausgeführt, wenn die Bedingung isJavaFun == true true ist.
   • else: Dieses Schlüsselwort leitet den Codeblock ein, der ausgeführt wird, wenn die if-Bedingung false ist.
   • System.out.println("Java is not fun.");: Diese Zeile wird ausgeführt, wenn die Bedingung isJavaFun == true false ist.

3. Speichern Sie die Datei (Strg+S oder Cmd+S).

4. Kompilieren Sie das Programm mit dem Befehl javac im Terminal:

   javac HelloJava.java

   Wenn keine Fehler auftreten, wird im Verzeichnis ~/project eine Datei HelloJava.class erstellt.

5. Führen Sie das kompilierte Programm mit dem Befehl java aus:

   java HelloJava

   Sie sollten die folgende Ausgabe sehen:

   Java is fun!

   Dies bestätigt, dass die if-Bedingung isJavaFun == true zu true ausgewertet wurde und die entsprechende Nachricht ausgegeben wurde.

Während die Verwendung von == true vollkommen gültig und leicht zu verstehen ist, können Sie in Java die Prüfung auf true vereinfachen. Da die if-Anweisung bereits den Ausdruck in den Klammern als booleschen Wert auswertet, können Sie direkt die boolesche Variable selbst als Bedingung verwenden.

Ändern wir den Code, um diesen vereinfachten Ansatz zu verwenden:

1. Öffnen Sie HelloJava.java erneut im Editor.

2. Ändern Sie die if-Anweisung wie folgt:

   if (isJavaFun) {
       System.out.println("Java is fun!");
   } else {
       System.out.println("Java is not fun.");
   }

   Beachten Sie, dass wir == true entfernt haben. Die Anweisung if (isJavaFun) ist äquivalent zu if (isJavaFun == true).

3. Speichern Sie die Datei.

4. Kompilieren Sie das geänderte Programm:

   javac HelloJava.java

5. Führen Sie das Programm erneut aus:

   java HelloJava

   Sie erhalten die gleiche Ausgabe:

   Java is fun!

   Dies zeigt, dass die direkte Verwendung der booleschen Variable in der if-Bedingung ein kompakterer und idiomatischer Weg ist, um zu prüfen, ob sie true ist.

Zusammenfassend können Sie den Gleichheitsoperator == true verwenden, um zu prüfen, ob ein boolescher Wert true ist. Der gebräuchlichere und sauberere Weg ist jedoch, einfach die boolesche Variable selbst als Bedingung in einer if-Anweisung zu verwenden.

Test mit der Boolean-Wrapper-Klasse

Im vorherigen Schritt haben wir mit dem primitiven boolean-Typ gearbeitet. Java verfügt auch über eine entsprechende Wrapper-Klasse namens Boolean. Wrapper-Klassen bieten eine Möglichkeit, primitive Datentypen als Objekte zu verwenden. Dies ist besonders nützlich, wenn Sie mit Sammlungen (Collections) arbeiten oder wenn Sie einen booleschen Wert darstellen müssen, der möglicherweise null sein kann.

Die Boolean-Klasse verfügt über zwei vordefinierte Objekte für die booleschen Werte: Boolean.TRUE und Boolean.FALSE. Dies sind konstante Objekte, die die booleschen Werte true und false darstellen.

Wenn Sie mit Boolean-Objekten arbeiten, können Sie immer noch den Gleichheitsoperator == verwenden, um sie zu vergleichen. Es ist jedoch wichtig zu verstehen, wie == mit Objekten funktioniert. Bei Objekten prüft ==, ob die beiden Variablen auf dasselbe exakte Objekt im Speicher verweisen, nicht nur, ob sie denselben Wert haben.

Ändern wir unser Programm, um die Boolean-Wrapper-Klasse zu verwenden und zu sehen, wie sich der Gleichheitsoperator verhält.

1. Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

2. Ersetzen Sie den Code durch folgenden:

   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.");
           }
       }
   }

   Schauen wir uns die Änderungen an:

   • Boolean isJavaFunObject = Boolean.TRUE;: Wir deklarieren eine Variable vom Typ Boolean und weisen ihr die Konstante Boolean.TRUE zu.
   • if (isJavaFunObject == Boolean.TRUE): Wir verwenden den Gleichheitsoperator ==, um unser Boolean-Objekt mit der Konstante Boolean.TRUE zu vergleichen. Da isJavaFunObject Boolean.TRUE zugewiesen ist, verweisen sie auf dasselbe Objekt, daher wird diese Bedingung true sein.
   • Boolean anotherBooleanObject = true;: Diese Zeile demonstriert "Autoboxing". Java konvertiert automatisch den primitiven boolean-Wert true in ein Boolean-Objekt.
   • if (anotherBooleanObject == Boolean.TRUE): Wir verwenden erneut ==, um anotherBooleanObject mit Boolean.TRUE zu vergleichen. Aufgrund der Funktionsweise des Autoboxing und der Zwischenspeicherung (Caching) von Boolean-Werten in Java verweisen die automatisch verpackten Boolean-Objekte für die Werte true und false oft auf dieselben zwischengespeicherten Instanzen wie Boolean.TRUE und Boolean.FALSE. Daher wird diese Bedingung ebenfalls wahrscheinlich true sein.

3. Speichern Sie die Datei.

4. Kompilieren Sie das Programm:

   javac HelloJava.java

5. Führen Sie das Programm aus:

   java HelloJava

   Sie sollten die folgende Ausgabe sehen:

   Java is fun (using Boolean.TRUE)!
   Another boolean object is true!

   Dies bestätigt, dass die Verwendung von == mit Boolean.TRUE in diesen Fällen wie erwartet funktioniert, da die Variablen wahrscheinlich auf dasselbe zugrunde liegende Boolean.TRUE-Objekt verweisen.

Allerdings kann das Verlassen auf == für den Vergleich von Boolean-Objekten in komplexeren Szenarien riskant sein, insbesondere wenn die Boolean-Objekte auf verschiedene Weise erstellt wurden oder aus verschiedenen Quellen stammen. Ein sichererer und empfohlener Weg, um Boolean-Objekte auf Wertgleichheit zu vergleichen, ist die Verwendung der .equals()-Methode.

Ändern wir den Code, um .equals() zu verwenden.

1. Öffnen Sie HelloJava.java im Editor.

2. Ändern Sie die if-Anweisungen, um .equals() zu verwenden:

   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).");
           }
       }
   }

   Wir haben == Boolean.TRUE durch .equals(Boolean.TRUE) ersetzt. Die .equals()-Methode vergleicht den Wert der Objekte, nicht ihre Speicheradresse.

3. Speichern Sie die Datei.

4. Kompilieren Sie das Programm:

   javac HelloJava.java

5. Führen Sie das Programm aus:

   java HelloJava

   Sie sollten die folgende Ausgabe sehen:

   Java is fun (using equals)!
   Another boolean object is true (using equals)!

   Die Verwendung von .equals() ist der Standard und der sicherste Weg, um Boolean-Objekte auf Wertgleichheit zu vergleichen.

Zusammenfassend lässt sich sagen, dass == zwar aufgrund der Zwischenspeicherung (Caching) für den Vergleich von Boolean-Objekten mit Boolean.TRUE funktionieren kann, aber die .equals()-Methode die bevorzugte und zuverlässigere Möglichkeit ist, um zu prüfen, ob ein Boolean-Objekt den Wert true repräsentiert.

Umgang mit Null-Booleans

Im vorherigen Schritt haben wir uns mit der Boolean-Wrapper-Klasse beschäftigt. Ein wesentlicher Unterschied zwischen dem primitiven boolean und der Boolean-Wrapper-Klasse besteht darin, dass eine Boolean-Variable den Wert null annehmen kann, während ein primitives boolean dies nicht kann. Der Umgang mit null-Werten ist in Java von entscheidender Bedeutung, um NullPointerException-Fehler zu vermeiden.

Eine NullPointerException tritt auf, wenn Sie versuchen, eine Variable zu verwenden, die derzeit auf null zeigt, als ob es sich um ein gültiges Objekt handelte. Beispielsweise führt das Aufrufen einer Methode auf einem null-Objekt zu einer NullPointerException.

Wenn Sie prüfen möchten, ob ein Boolean-Objekt true ist, müssen Sie vorsichtig sein, wenn das Objekt möglicherweise null ist.

Schauen wir uns an, was passiert, wenn wir versuchen, ein null-Boolean mit den bisher gelernten Methoden zu prüfen.

1. Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

2. Ersetzen Sie den Code durch folgenden:

   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.");
           // }
       }
   }

   In diesem Code:

   • Boolean nullableBoolean = null;: Wir deklarieren eine Boolean-Variable und setzen sie explizit auf null.
   • if (nullableBoolean == true): Wir verwenden den Gleichheitsoperator ==, um das null-Boolean mit dem primitiven true zu vergleichen. Beim Vergleich eines Boolean-Objekts (auch wenn es null ist) mit einem primitiven boolean führt Java ein "Unboxing" durch. Es versucht, das Boolean-Objekt in ein primitives boolean umzuwandeln. Wenn das Boolean-Objekt null ist, führt dieser Unboxing-Prozess zu einer NullPointerException.
   • Die auskommentierte .equals()-Prüfung würde ebenfalls eine NullPointerException verursachen, da Sie versuchen, die .equals()-Methode auf einem null-Objekt (nullableBoolean) aufzurufen.

3. Speichern Sie die Datei.

4. Kompilieren Sie das Programm:

   javac HelloJava.java

5. Führen Sie das Programm aus:

   java HelloJava

   Sie werden in der Konsole eine Fehlermeldung sehen, die auf eine NullPointerException hinweist:

   Exception in thread "main" java.lang.NullPointerException
       at HelloJava.main(HelloJava.java:6)

   Dies zeigt, dass das direkte Vergleichen eines möglicherweise null-Werts Boolean mit einem primitiven boolean mithilfe von == oder das Aufrufen von .equals() darauf zu einer NullPointerException führen kann.

Um möglicherweise null-Werte Boolean-Objekte sicher zu behandeln, sollten Sie immer prüfen, ob das Objekt null ist, bevor Sie es entpacken oder Methoden darauf aufrufen.

So können Sie sicher prüfen, ob ein Boolean-Objekt true ist:

1. Öffnen Sie HelloJava.java im Editor.

2. Ersetzen Sie den Code durch folgenden:

   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).");
            }
       }
   }

   In diesem aktualisierten Code:

   • if (nullableBoolean != null && nullableBoolean == true): Wir prüfen zunächst, ob nullableBoolean nicht null ist, indem wir nullableBoolean != null verwenden. Der &&-Operator bedeutet, dass der zweite Teil der Bedingung (nullableBoolean == true) nur ausgewertet wird, wenn der erste Teil (nullableBoolean != null) true ist. Dies verhindert die NullPointerException. Wenn nullableBoolean null ist, ist der erste Teil false, und die gesamte Bedingung ist false, ohne dass der zweite Teil ausgewertet wird.
   • if (Boolean.TRUE.equals(nullableBoolean)): Dies ist eine weitere sichere Möglichkeit, zu prüfen, ob ein Boolean-Objekt true ist, auch wenn es null ist. Indem wir die .equals()-Methode auf dem bekannten nicht-null-Objekt Boolean.TRUE aufrufen und das möglicherweise null-Objekt nullableBoolean als Argument übergeben, vermeiden wir die NullPointerException. Die .equals()-Methode ist so konzipiert, dass sie null-Argumente gracefully behandelt; Boolean.TRUE.equals(null) gibt einfach false zurück.

3. Speichern Sie die Datei.

4. Kompilieren Sie das Programm:

   javac HelloJava.java

5. Führen Sie das Programm aus:

   java HelloJava

   Sie sollten die folgende Ausgabe sehen:

   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).

   Dies zeigt, wie Sie den Wert eines Boolean-Objekts sicher prüfen können, auch wenn es möglicherweise null ist, indem Sie sowohl die != null-Prüfung in Kombination mit == true als auch die Boolean.TRUE.equals()-Methode verwenden.

Denken Sie immer daran, die Möglichkeit von null zu berücksichtigen, wenn Sie mit Boolean-Objekten arbeiten, um Laufzeitfehler zu vermeiden.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java prüft, ob eine boolesche Variable true ist. Wir haben begonnen, indem wir den Gleichheitsoperator == verwendet haben, um eine boolesche Variable direkt mit dem booleschen Literal true zu vergleichen. Dies ist die häufigste und einfachste Methode, um den Wert eines primitiven booleschen Datentyps zu prüfen.

Wir haben auch untersucht, wie man Boolean-Wrapper-Objekte behandelt, die null sein können. Wir haben gelernt, dass das direkte Vergleichen eines Boolean-Objekts mit true mithilfe von == möglicherweise nicht wie erwartet funktioniert, da es sich um die Identität von Objekten handelt. Stattdessen sollten wir die equals()-Methode verwenden oder das Boolean-Objekt in seinen primitiven booleschen Wert entpacken, bevor wir es vergleichen. Schließlich haben wir die Wichtigkeit des Umgangs mit potenziellen NullPointerException beim Arbeiten mit nullable Boolean-Objekten betont, indem wir auf null prüfen, bevor wir versuchen, ihren Wert zuzugreifen.