Wie man prüft, ob ein Boolean in Java null ist

Einführung

In diesem Lab lernen Sie, wie Sie null-Werte sicher behandeln können, wenn Sie mit Boolean-Objekten in Java arbeiten. Wir werden die potenziellen Fallstricke der NullPointerException untersuchen, die beim Umgang mit der Boolean-Wrapper-Klasse im Vergleich zum primitiven boolean-Typ auftreten können.

Sie werden die richtige Methode lernen, um zu prüfen, ob ein Boolean-Objekt null ist, bevor Sie auf seinen Wert zugreifen. Außerdem werden Sie die Optional-Klasse für eine robusteres null-Handling nutzen und die wichtigsten Unterschiede im Verhalten bei null-Werten zwischen dem primitiven boolean und der Boolean-Wrapper-Klasse anhand praktischer Beispiele verstehen.

Prüfen, ob ein Boolean-Objekt null ist

In diesem Schritt werden wir untersuchen, wie man potenzielle null-Werte beim Arbeiten mit Boolean-Objekten in Java behandeln kann. Im Gegensatz zu primitiven boolean-Typen, die immer entweder true oder false sind, kann die Boolean-Wrapper-Klasse einen null-Wert enthalten. Dies ist eine häufige Ursache für NullPointerException-Fehler, wenn es nicht sorgfältig behandelt wird.

Lassen Sie uns ein einfaches Java-Programm erstellen, um dies zu demonstrieren.

Öffnen Sie den WebIDE-Editor.
Stellen Sie im Dateiexplorer links sicher, dass Sie sich im Verzeichnis ~/project befinden.
Klicken Sie mit der rechten Maustaste in den leeren Bereich des Dateiexplorers, wählen Sie "Neue Datei" und benennen Sie sie BooleanCheck.java.
Öffnen Sie die Datei BooleanCheck.java im Editor.
Kopieren und fügen Sie den folgenden Code in den Editor ein:
```
public class BooleanCheck {
    public static void main(String[] args) {
        Boolean myBoolean = null;

        // This will cause a NullPointerException if myBoolean is null
        // if (myBoolean) {
        //     System.out.println("myBoolean is true");
        // }

        // Correct way to check for null before accessing the boolean value
        if (myBoolean != null && myBoolean) {
            System.out.println("myBoolean is true");
        } else if (myBoolean == null) {
            System.out.println("myBoolean is null");
        } else {
            System.out.println("myBoolean is false");
        }
    }
}
```
In diesem Code:
- Wir deklarieren ein Boolean-Objekt myBoolean und initialisieren es mit null.
- Die auskommentierte Zeile if (myBoolean) zeigt einen häufigen Fehler, der zu einer NullPointerException führt, wenn myBoolean null ist.
- Die Zeile if (myBoolean != null && myBoolean) zeigt die richtige Methode, um zu prüfen, ob das Boolean-Objekt nicht null ist, bevor man versucht, seinen booleschen Wert auszuwerten. Der &&-Operator ist ein Kurzschlussoperator, was bedeutet, dass wenn myBoolean != null falsch ist, der zweite Teil (myBoolean) nicht ausgewertet wird, wodurch der Fehler vermieden wird.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Öffnen Sie das Terminal unten im WebIDE. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden, indem Sie den Befehl cd ~/project eingeben.
Kompilieren Sie das Java-Programm, indem Sie den folgenden Befehl eingeben und die Eingabetaste drücken:
```
javac BooleanCheck.java
```
Wenn keine Fehler auftreten, sehen Sie keine Ausgabe. Eine Datei BooleanCheck.class wird im Verzeichnis ~/project erstellt.
Führen Sie das kompilierte Programm aus, indem Sie den folgenden Befehl eingeben und die Eingabetaste drücken:
```
java BooleanCheck
```
Sie sollten die folgende Ausgabe sehen:
```
myBoolean is null
```

Diese Ausgabe bestätigt, dass unser Programm korrekt erkannt hat, dass myBoolean null war und die NullPointerException vermieden hat. Das Verständnis, wie man null-Werte bei Boolean-Objekten behandelt, ist entscheidend für das Schreiben robuster Java-Code.

Verwenden von Optional für die Null-Behandlung

In diesem Schritt werden wir einen moderneren Ansatz zur Behandlung potenzieller null-Werte in Java mithilfe der Optional-Klasse untersuchen, die in Java 8 eingeführt wurde. Optional ist ein Containerobjekt, das einen nicht-null-Wert enthalten kann oder auch nicht. Es bietet eine klare Möglichkeit, anzuzeigen, dass ein Wert fehlen kann, hilft dabei, NullPointerException-Fehler zu vermeiden und macht den Code lesbarer.

Lassen Sie uns unser vorheriges Beispiel ändern, um Optional<Boolean> zu verwenden.

Öffnen Sie die Datei BooleanCheck.java im WebIDE-Editor.

Ersetzen Sie den gesamten Inhalt der Datei durch den folgenden neuen Code:

import java.util.Optional;

public class BooleanCheck {
    public static void main(String[] args) {
        // Creating an Optional that contains a Boolean value
        Optional<Boolean> optionalBooleanPresent = Optional.of(true);

        // Creating an Optional that is empty (represents null)
        Optional<Boolean> optionalBooleanEmpty = Optional.empty();

        // Handling the present Optional
        if (optionalBooleanPresent.isPresent()) {
            System.out.println("optionalBooleanPresent has a value: " + optionalBooleanPresent.get());
        } else {
            System.out.println("optionalBooleanPresent is empty");
        }

        // Handling the empty Optional
        if (optionalBooleanEmpty.isPresent()) {
            System.out.println("optionalBooleanEmpty has a value: " + optionalBooleanEmpty.get());
        } else {
            System.out.println("optionalBooleanEmpty is empty");
        }

        // Using orElse to provide a default value if the Optional is empty
        Boolean valueOrDefault = optionalBooleanEmpty.orElse(false);
        System.out.println("Value from optionalBooleanEmpty orElse(false): " + valueOrDefault);

        // Using ifPresent to perform an action only if a value is present
        optionalBooleanPresent.ifPresent(value -> System.out.println("Value is present: " + value));
    }
}

In diesem aktualisierten Code:

Wir importieren die java.util.Optional-Klasse.
Wir erstellen zwei Optional<Boolean>-Objekte: eines mit einem Wert (Optional.of(true)) und eines, das leer ist (Optional.empty()).
Wir verwenden isPresent(), um zu prüfen, ob ein Optional einen Wert enthält.
Wir verwenden get(), um den Wert aus einem Optional abzurufen. Hinweis: Das Aufrufen von get() auf einem leeren Optional löst eine NoSuchElementException aus. Prüfen Sie daher immer zuerst mit isPresent() oder verwenden Sie andere Optional-Methoden.
Wir demonstrieren orElse(false), das den enthaltenen Wert zurückgibt, wenn vorhanden, andernfalls den angegebenen Standardwert (false in diesem Fall).
Wir zeigen ifPresent(), das einen Lambda-Ausdruck nimmt und ihn nur ausführt, wenn ein Wert im Optional vorhanden ist.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Öffnen Sie das Terminal unten im WebIDE. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden, indem Sie den Befehl cd ~/project eingeben.
Kompilieren Sie das Java-Programm, indem Sie den folgenden Befehl eingeben und die Eingabetaste drücken:
```
javac BooleanCheck.java
```
Wenn die Kompilierung erfolgreich ist, wird eine neue Datei BooleanCheck.class generiert.

Führen Sie das kompilierte Programm aus, indem Sie den folgenden Befehl eingeben und die Eingabetaste drücken:

java BooleanCheck

Sie sollten die folgende Ausgabe sehen:

optionalBooleanPresent has a value: true
optionalBooleanEmpty is empty
Value from optionalBooleanEmpty orElse(false): false
Value is present: true

Diese Ausgabe zeigt, wie Optional verwendet werden kann, um das Vorhandensein oder Fehlen eines Werts auf eine explizitere und sicherere Weise zu behandeln als nur die Verwendung von null. Die Verwendung von Optional kann Ihren Code klarer gestalten und die Wahrscheinlichkeit von NullPointerExceptions verringern.

Testen mit primitiven Datentypen vs. Wrapper-Klassen

In diesem Schritt werden wir den wesentlichen Unterschied zwischen Java's primitivem boolean-Typ und der Boolean-Wrapper-Klasse herausstellen, insbesondere in Bezug auf ihre Fähigkeit, null zu sein. Das Verständnis dieser Unterscheidung ist grundlegend, um NullPointerExceptions beim Arbeiten mit booleschen Werten zu vermeiden.

Primitiver boolean: Dies ist ein grundlegender Datentyp in Java. Er kann nur einen von zwei Werten enthalten: true oder false. Eine primitive boolean-Variable kann niemals null sein.
Boolean-Wrapper-Klasse: Dies ist ein Objekt, das einen primitiven boolean-Wert umhüllt. Da es sich um ein Objekt handelt, kann eine Boolean-Variable eine Referenz auf ein Boolean-Objekt (das true oder false enthält) oder den Wert null enthalten.

Lassen Sie uns ein einfaches Programm erstellen, um diesen Unterschied zu demonstrieren.

Öffnen Sie den WebIDE-Editor.
Stellen Sie im Dateiexplorer links sicher, dass Sie sich im Verzeichnis ~/project befinden.
Klicken Sie mit der rechten Maustaste in den leeren Bereich des Dateiexplorers, wählen Sie "Neue Datei" und benennen Sie sie PrimitiveVsWrapper.java.
Öffnen Sie die Datei PrimitiveVsWrapper.java im Editor.

Kopieren und fügen Sie den folgenden Code in den Editor ein:

public class PrimitiveVsWrapper {
    public static void main(String[] args) {
        // Declaring a primitive boolean
        boolean primitiveBoolean = true;

        // Declaring a Boolean wrapper object
        Boolean wrapperBoolean = null; // Wrapper can be null

        System.out.println("Primitive boolean value: " + primitiveBoolean);

        // Checking if the wrapper Boolean is null before printing
        if (wrapperBoolean == null) {
            System.out.println("Wrapper Boolean is null");
        } else {
            System.out.println("Wrapper Boolean value: " + wrapperBoolean);
        }

        // Attempting to assign null to a primitive boolean will cause a compile-time error
        // primitiveBoolean = null; // Uncommenting this line will cause an error
    }
}

In diesem Code:

Wir deklarieren einen primitiven boolean und initialisieren ihn mit true.
Wir deklarieren ein Boolean-Wrapper-Objekt und initialisieren es mit null. Dies ist für die Wrapper-Klasse gültig.
Wir geben den Wert des primitiven boolean aus.
Wir prüfen, ob der Wrapper-boolean null ist, bevor wir versuchen, seinen Wert auszugeben, was die Notwendigkeit von null-Prüfungen bei Wrapper-Typen zeigt.
Die auskommentierte Zeile zeigt, dass Sie null nicht einem primitiven boolean zuweisen können. Wenn Sie diese Zeile einkommentieren und versuchen, zu kompilieren, erhalten Sie einen Kompilierungsfehler.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Öffnen Sie das Terminal unten im WebIDE. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden, indem Sie den Befehl cd ~/project eingeben.
Kompilieren Sie das Java-Programm, indem Sie den folgenden Befehl eingeben und die Eingabetaste drücken:
```
javac PrimitiveVsWrapper.java
```
Wenn keine Fehler auftreten, wird eine Datei PrimitiveVsWrapper.class erstellt.
Führen Sie das kompilierte Programm aus, indem Sie den folgenden Befehl eingeben und die Eingabetaste drücken:
```
java PrimitiveVsWrapper
```
Sie sollten die folgende Ausgabe sehen:
```
Primitive boolean value: true
Wrapper Boolean is null
```

Diese Ausgabe zeigt deutlich, dass der primitive boolean einen Wert (true) enthält, während das Boolean-Wrapper-Objekt null enthalten kann. Diese Unterscheidung ist wichtig, wenn Sie Ihre Java-Programme entwerfen und potenzielle fehlende Werte behandeln.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man potenzielle null-Werte beim Arbeiten mit Boolean-Objekten in Java behandelt. Wir haben gesehen, dass im Gegensatz zu primitiven boolean-Typen die Boolean-Wrapper-Klasse null sein kann, was zu NullPointerException-Fehlern führen kann. Wir haben gezeigt, wie man korrekt prüft, ob ein Boolean-Objekt nicht null ist, bevor man auf seinen booleschen Wert zugreift, indem man die != null-Prüfung mit dem logischen UND-Operator (&&) kombiniert. Dies stellt sicher, dass der boolesche Wert nur ausgewertet wird, wenn das Objekt nicht null ist, wodurch Laufzeitfehler vermieden werden.