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

Einführung

In diesem Lab lernen Sie, wie Sie in Java prüfen können, ob eine boolesche Variable false ist. Wir werden grundlegende Techniken zur Arbeit mit booleschen Werten untersuchen, die für die Steuerung des Programmflusses basierend auf Bedingungen unerlässlich sind.

Durch praktische Beispiele üben Sie die Verwendung des Gleichheitsoperators (==) zur Prüfung auf false, testen mit Boolean-Objekten und kombinieren Prüfungen für true- und false-Bedingungen. Am Ende dieses Labs werden Sie ein solides Verständnis dafür haben, wie Sie boolesche Variablen effektiv in Ihren Java-Programmen nutzen können.

Verwendung des Gleichheitsoperators zur Prüfung auf `false`

In diesem Schritt werden wir untersuchen, wie Sie in Java prüfen können, ob eine boolesche Variable false ist, indem Sie den Gleichheitsoperator (==) verwenden. Das Verständnis, wie man mit booleschen Werten arbeitet, ist in der Programmierung grundlegend, da sie verwendet werden, um den Fluss Ihres Programms basierend auf Bedingungen zu steuern.

Eine boolesche Variable kann einen von zwei Werten annehmen: true oder false. Diese Werte sind oft das Ergebnis eines Vergleichs oder einer logischen Operation.

Erstellen wir ein einfaches Java-Programm, um die Prüfung auf false zu demonstrieren.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.
Ersetzen Sie den vorhandenen Code durch folgenden:
```
public class HelloJava {
    public static void main(String[] args) {
        boolean isComplete = false;

        if (isComplete == false) {
            System.out.println("The task is not complete.");
        }
    }
}
```
Schauen wir uns die neuen Teile an:
- boolean isComplete = false;: Diese Zeile deklariert eine boolesche Variable namens isComplete und initialisiert sie mit dem Wert false.
- if (isComplete == false): Dies ist eine if-Anweisung, die verwendet wird, um einen Codeblock nur auszuführen, wenn eine bestimmte Bedingung wahr ist. Die Bedingung hier ist isComplete == false. Der ==-Operator prüft, ob der Wert von isComplete gleich false ist.
- System.out.println("The task is not complete.");: Diese Zeile wird nur ausgeführt, wenn die Bedingung isComplete == false wahr ist.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm mit dem Befehl javac im Terminal:
```
javac HelloJava.java
```
Wenn keine Fehler auftreten, sehen Sie keine Ausgabe.
Führen Sie das kompilierte Programm mit dem Befehl java aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
The task is not complete.
```
Diese Ausgabe bestätigt, dass die Bedingung isComplete == false tatsächlich wahr war und der Code innerhalb des if-Blocks ausgeführt wurde.

Die Verwendung des Gleichheitsoperators (==) zur Prüfung, ob ein boolescher Wert false ist, ist eine einfache Möglichkeit, diese Bedingung auszudrücken. Im nächsten Schritt werden wir eine andere Möglichkeit zur Prüfung auf den Wert false untersuchen.

Testen mit einem Boolean-Objekt

Im vorherigen Schritt haben wir mit einem primitiven booleschen Typ gearbeitet. Java hat auch eine entsprechende Klasse namens Boolean, die ein Objektwrapper für den primitiven booleschen Typ ist. Obwohl Sie oft den primitiven Typ verwenden werden, ist es nützlich, etwas über das Boolean-Objekt zu wissen, insbesondere wenn Sie mit Sammlungen (Collections) oder Methoden arbeiten, die Objekte erfordern.

In diesem Schritt werden wir sehen, wie man den Wert false prüft, wenn man ein Boolean-Objekt verwendet.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Ersetzen Sie den aktuellen Code durch folgenden:
```
public class HelloJava {
    public static void main(String[] args) {
        Boolean isProcessed = Boolean.FALSE;

        if (isProcessed.equals(false)) {
            System.out.println("The item has not been processed.");
        }
    }
}
```
Schauen wir uns die Änderungen an:
- Boolean isProcessed = Boolean.FALSE;: Diese Zeile deklariert ein Boolean-Objekt namens isProcessed und initialisiert es mit der statischen Konstante Boolean.FALSE, die den booleschen Wert false repräsentiert.
- if (isProcessed.equals(false)): Wenn man in Java mit Objekten arbeitet, wird im Allgemeinen empfohlen, die equals()-Methode zur Vergleich ihrer Werte zu verwenden, anstatt den ==-Operator. Die equals()-Methode der Boolean-Klasse prüft, ob der boolesche Wert des Objekts gleich dem als Argument übergebenen booleschen Wert ist.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm mit javac im Terminal:
```
javac HelloJava.java
```
Wiederum bedeutet die fehlende Ausgabe, dass die Kompilierung erfolgreich war.
Führen Sie das Programm mit java aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
The item has not been processed.
```
Dies zeigt, dass die equals()-Methode korrekt erkannt hat, dass das Boolean-Objekt isProcessed den booleschen Wert false enthält.

Während die Verwendung von == false mit primitiven booleschen Werten üblich und völlig in Ordnung ist, ist die Verwendung von .equals(false) die Standardmethode zum Vergleichen von Boolean-Objekten. Das Verständnis des Unterschieds zwischen primitiven Typen und ihren Objektwrappern ist ein wichtiges Konzept in Java.

Kombination von Prüfungen auf true und false

In der realen Programmierung müssen Sie oft mehrere Bedingungen gleichzeitig prüfen. Dies beinhaltet die Kombination von Prüfungen auf true- und false-Werte mithilfe von logischen Operatoren wie && (UND) und || (ODER).

In diesem Schritt werden wir unser Programm so ändern, dass es Prüfungen für sowohl true- als auch false-Bedingungen enthält.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Ersetzen Sie den aktuellen Code durch folgenden:
```
public class HelloJava {
    public static void main(String[] args) {
        boolean isTaskStarted = true;
        boolean isTaskFinished = false;

        if (isTaskStarted == true && isTaskFinished == false) {
            System.out.println("The task has started but is not finished.");
        }

        if (isTaskStarted == false || isTaskFinished == true) {
             System.out.println("The task is either not started or is already finished.");
        }
    }
}
```
Lassen Sie uns den neuen Code analysieren:
- boolean isTaskStarted = true;: Wir deklarieren eine boolesche Variable isTaskStarted und setzen sie auf true.
- boolean isTaskFinished = false;: Wir deklarieren eine weitere boolesche Variable isTaskFinished und setzen sie auf false.
- if (isTaskStarted == true && isTaskFinished == false): Diese if-Anweisung verwendet den logischen UND-Operator (&&). Der Code in diesem Block wird nur ausgeführt, wenn beide Bedingungen wahr sind: isTaskStarted ist true UND isTaskFinished ist false.
- if (isTaskStarted == false || isTaskFinished == true): Diese if-Anweisung verwendet den logischen ODER-Operator (||). Der Code in diesem Block wird ausgeführt, wenn mindestens eine der Bedingungen wahr ist: isTaskStarted ist false ODER isTaskFinished ist true.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm mit javac im Terminal:
```
javac HelloJava.java
```
Führen Sie das Programm mit java aus:
```
java HelloJava
```
Basierend auf den Anfangswerten von isTaskStarted und isTaskFinished sollten Sie die folgende Ausgabe sehen:
```
The task has started but is not finished.
```
Die erste if-Bedingung (true && false) ergibt true, also wird die erste println-Anweisung ausgeführt. Die zweite if-Bedingung (true || false) ergibt false, also wird die zweite println-Anweisung nicht ausgeführt.

Warten Sie, die Ausgabe ist nur "The task has started but is not finished."? Lassen Sie uns die Bedingungen erneut auswerten:
- isTaskStarted == true && isTaskFinished == false: true == true ist true, false == false ist true. true && true ist true. Also wird die erste Nachricht ausgegeben.
- isTaskStarted == false || isTaskFinished == true: true == false ist false, false == true ist false. false || false ist false. Also wird die zweite Nachricht nicht ausgegeben.
Entschuldigung, die erwartete Ausgabe ist tatsächlich nur die erste Zeile. Dies zeigt, wie logische Operatoren Bedingungen kombinieren.

Sie können experimentieren, indem Sie die Anfangswerte von isTaskStarted und isTaskFinished ändern und das Programm erneut ausführen, um zu sehen, wie sich die Ausgabe ändert.

Das Kombinieren von booleschen Prüfungen mit logischen Operatoren ist eine leistungsstarke Methode, um den Fluss Ihres Programms zu steuern und Entscheidungen auf der Grundlage mehrerer Faktoren zu treffen.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob eine boolesche Variable in Java false ist. Wir begannen damit, den Gleichheitsoperator (==) zu verwenden, um eine boolesche Variable direkt mit dem false-Literal zu vergleichen. Dies zeigte die grundlegende Methode, um eine false-Bedingung zu prüfen und den Programmfluss mithilfe einer if-Anweisung zu steuern. Anschließend haben wir dieses Konzept mit einem einfachen Java-Programm getestet, indem wir es kompilierten und ausführten, um die erwartete Ausgabe zu beobachten, wenn die boolesche Variable tatsächlich false war.