Wie man prüft, ob ein Double-Objekt in Java null ist

Einführung

In diesem Lab lernen Sie, wie Sie in Java prüfen können, ob ein Double-Objekt null ist. Wir werden den Unterschied zwischen dem primitiven Datentyp double und der Double-Wrapper-Klasse untersuchen und erfahren, wie man potenzielle NullPointerException-Fehler behandelt.

Das Lab führt Sie durch die Prüfung auf null mithilfe des Gleichheitsoperators, die Unterscheidung zwischen null- und Nullwerten (null und 0) und die Verwendung der Optional-Klasse für eine robusteres Null-Handling. Sie werden Codebeispiele implementieren und testen, um Ihr Verständnis dieser Konzepte zu festigen.

Prüfen, ob der Double-Wrapper null ist

In diesem Schritt werden wir untersuchen, wie man Double-Wrapper-Objekte in Java behandelt, insbesondere wie man prüft, ob eine Double-Variable null ist. Im Gegensatz zu primitiven Datentypen wie double können Wrapper-Klassen wie Double einen null-Wert enthalten, der die Abwesenheit eines Wertes darstellt. Es ist wichtig, null-Werte korrekt zu behandeln, um NullPointerException-Fehler in Ihren Programmen zu vermeiden.

Lassen Sie uns ein einfaches Java-Programm erstellen, um das Prüfen auf null in einem Double-Objekt zu demonstrieren.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor. Wenn Sie sie nicht geöffnet haben, können Sie sie im Dateiexplorer links im Verzeichnis ~/project finden.
Ersetzen Sie den vorhandenen Code in HelloJava.java durch den folgenden Code:
```
public class HelloJava {
    public static void main(String[] args) {
        Double price = null; // Deklariere eine Double-Variable und initialisiere sie mit null

        if (price == null) {
            System.out.println("Price is not set (it is null).");
        } else {
            System.out.println("Price is set to: " + price);
        }

        Double quantity = 10.5; // Deklariere eine weitere Double-Variable und weise ihr einen Wert zu

        if (quantity == null) {
            System.out.println("Quantity is not set (it is null).");
        } else {
            System.out.println("Quantity is set to: " + quantity);
        }
    }
}
```
Schauen wir uns die neuen Teile dieses Codes an:
- Double price = null;: Wir deklarieren eine Variable namens price vom Typ Double und weisen ihr den Wert null zu.
- if (price == null): Dies ist eine if-Anweisung, die prüft, ob die Variable price gleich null ist. Der ==-Operator wird verwendet, um zu überprüfen, ob die Referenz auf das Objekt null ist.
- System.out.println("Price is not set (it is null).");: Diese Zeile wird ausgeführt, wenn price tatsächlich null ist.
- Double quantity = 10.5;: Wir deklarieren eine weitere Double-Variable namens quantity und weisen ihr einen numerischen Wert zu.
- Die zweite if-Anweisung prüft, ob quantity null ist. Da wir ihr einen Wert zugewiesen haben, wird diese Bedingung falsch sein.
Speichern Sie die Datei HelloJava.java (Strg+S oder Cmd+S).
Jetzt kompilieren Sie das geänderte Programm. Öffnen Sie das Terminal unten im WebIDE und führen Sie den folgenden Befehl aus:
```
javac HelloJava.java
```
Wenn die Kompilierung erfolgreich ist, sehen Sie keine Ausgabe.
Führen Sie schließlich das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
Price is not set (it is null).
Quantity is set to: 10.5
```
Diese Ausgabe bestätigt, dass unser Programm korrekt erkannt hat, dass price null war und quantity einen Wert hatte.

Das Verständnis, wie man auf null prüft, ist grundlegend, wenn man mit Java-Objekten arbeitet, insbesondere mit Wrapper-Klassen. Im nächsten Schritt werden wir den Unterschied zwischen einem null-Double und einem Double mit dem Wert Null untersuchen.

Behandlung von Null- und Nullwerten

Im vorherigen Schritt haben wir gelernt, wie man prüft, ob ein Double-Wrapper-Objekt null ist. Jetzt wollen wir den Unterschied zwischen einem Double, der null ist, und einem Double, der den Wert Null (0.0) hat, untersuchen. Diese Unterscheidung ist wichtig, denn null bedeutet "kein Wert", während 0.0 ein spezifischer numerischer Wert ist.

Stellen Sie sich vor, Sie verfolgen den auf ein Produkt angewendeten Rabatt. Ein null-Rabatt könnte bedeuten, dass die Rabattinformationen nicht verfügbar sind, während ein Rabatt von 0.0 bedeutet, dass ausdrücklich kein Rabatt angewendet wird.

Lassen Sie uns unser HelloJava.java-Programm ändern, um diesen Unterschied zu demonstrieren.

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

Ersetzen Sie den vorhandenen Code durch den folgenden:

public class HelloJava {
    public static void main(String[] args) {
        Double discount = null; // Discount information not available

        if (discount == null) {
            System.out.println("Discount information is not available (it is null).");
        } else if (discount == 0.0) {
            System.out.println("There is no discount (value is 0.0).");
        } else {
            System.out.println("Discount applied: " + discount);
        }

        System.out.println("---"); // Separator for clarity

        Double zeroDiscount = 0.0; // Explicitly no discount

        if (zeroDiscount == null) {
            System.out.println("Discount information is not available (it is null).");
        } else if (zeroDiscount == 0.0) {
            System.out.println("There is no discount (value is 0.0).");
        } else {
            System.out.println("Discount applied: " + zeroDiscount);
        }

        System.out.println("---"); // Separator for clarity

        Double appliedDiscount = 5.5; // A specific discount value

        if (appliedDiscount == null) {
            System.out.println("Discount information is not available (it is null).");
        } else if (appliedDiscount == 0.0) {
            System.out.println("There is no discount (value is 0.0).");
        } else {
            System.out.println("Discount applied: " + appliedDiscount);
        }
    }
}

In diesem aktualisierten Code:

Wir führen drei Double-Variablen ein: discount (initialisiert mit null), zeroDiscount (initialisiert mit 0.0) und appliedDiscount (initialisiert mit 5.5).
Wir verwenden eine if-else if-else-Struktur, um den Zustand jeder Variable zu prüfen:
- Zuerst prüfen wir, ob die Variable null ist.
- Wenn sie nicht null ist, prüfen wir dann, ob ihr Wert 0.0 ist.
- Andernfalls gehen wir davon aus, dass ein spezifischer Rabattwert angewendet wird.

Speichern Sie die Datei HelloJava.java.
Kompilieren Sie das Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
Discount information is not available (it is null).
---
There is no discount (value is 0.0).
---
Discount applied: 5.5
```
Diese Ausgabe zeigt deutlich, wie Java zwischen einem null-Double und einem Double mit dem Wert 0.0 unterscheidet. Das korrekte Handhaben dieser Fälle ist für das Schreiben robuster Java-Anwendungen unerlässlich.

Im nächsten Schritt werden wir einen moderneren Ansatz zum Umgang mit potenziellen null-Werten mithilfe der Optional-Klasse untersuchen, der Ihren Code sicherer und lesbarer machen kann.

Testen mit der Optional-Klasse

In modernem Java (Java 8 und neuer) wird die Optional-Klasse oft verwendet, um einen Wert darzustellen, der vorhanden sein kann oder auch nicht. Dies bietet eine explizitere und sicherere Möglichkeit, potenzielle null-Werte zu behandeln, im Vergleich zur einfachen Verwendung von null-Referenzen. Die Verwendung von Optional kann helfen, NullPointerException-Fehler zu vermeiden und Ihren Code lesbarer zu machen.

Lassen Sie uns unser Rabattbeispiel unter Verwendung der Optional<Double>-Klasse neu schreiben.

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

Ersetzen Sie den vorhandenen Code durch den folgenden:

import java.util.Optional;

public class HelloJava {
    public static void main(String[] args) {
        // Representing a discount that might be null
        Optional<Double> optionalDiscount = Optional.empty();

        if (optionalDiscount.isPresent()) {
            System.out.println("Discount is present: " + optionalDiscount.get());
        } else {
            System.out.println("Discount is not present (Optional is empty).");
        }

        System.out.println("---"); // Separator for clarity

        // Representing a discount with a value of 0.0
        Optional<Double> optionalZeroDiscount = Optional.of(0.0);

        if (optionalZeroDiscount.isPresent()) {
            System.out.println("Discount is present: " + optionalZeroDiscount.get());
        } else {
            System.out.println("Discount is not present (Optional is empty).");
        }

        System.out.println("---"); // Separator for clarity

        // Representing a discount with a specific value
        Optional<Double> optionalAppliedDiscount = Optional.of(5.5);

        if (optionalAppliedDiscount.isPresent()) {
            System.out.println("Discount is present: " + optionalAppliedDiscount.get());
        } else {
            System.out.println("Discount is not present (Optional is empty).");
        }

        System.out.println("---"); // Separator for clarity

        // A common way to handle Optional: using orElse
        Double finalDiscount = optionalDiscount.orElse(0.0);
        System.out.println("Using orElse: Final discount is " + finalDiscount);

        Double finalZeroDiscount = optionalZeroDiscount.orElse(0.0);
        System.out.println("Using orElse: Final zero discount is " + finalZeroDiscount);
    }
}

Schauen wir uns die wichtigsten Änderungen an:

import java.util.Optional;: Wir importieren die Optional-Klasse.
Optional<Double> optionalDiscount = Optional.empty();: Wir erstellen ein leeres Optional<Double>, das die Abwesenheit eines Rabattwerts darstellt.
Optional<Double> optionalZeroDiscount = Optional.of(0.0);: Wir erstellen ein Optional<Double>, das den Wert 0.0 enthält. Optional.of() wird verwendet, wenn Sie sicher sind, dass der Wert nicht null ist.
Optional<Double> optionalAppliedDiscount = Optional.of(5.5);: Wir erstellen ein Optional<Double>, das den Wert 5.5 enthält.
optionalDiscount.isPresent(): Diese Methode prüft, ob das Optional einen Wert enthält. Sie ist die empfohlene Methode zum Prüfen, anstatt mit null zu vergleichen.
optionalDiscount.get(): Diese Methode ruft den Wert aus dem Optional ab. Achtung: Wenn das Optional leer ist, löst der Aufruf von get() eine NoSuchElementException aus. Prüfen Sie immer isPresent() bevor Sie get() aufrufen, oder verwenden Sie alternative Methoden wie orElse().
optionalDiscount.orElse(0.0): Diese Methode gibt den Wert innerhalb des Optional zurück, wenn er vorhanden ist; andernfalls gibt sie den bereitgestellten Standardwert zurück (in diesem Fall 0.0). Dies ist eine sichere Möglichkeit, einen Wert zu erhalten und den Fall zu behandeln, dass das Optional leer ist.

Speichern Sie die Datei HelloJava.java.
Kompilieren Sie das Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
Discount is not present (Optional is empty).
---
Discount is present: 0.0
---
Discount is present: 5.5
---
Using orElse: Final discount is 0.0
Using orElse: Final zero discount is 0.0
```
Diese Ausgabe zeigt, wie Optional uns hilft, Fälle, in denen ein Wert fehlen könnte, explizit zu behandeln. Die Verwendung von Optional kann zu sauberem und robusterem Code führen, indem es das Risiko von NullPointerException verringert.

Sie haben nun gelernt, wie man in Double-Wrapper-Objekten auf null prüft, zwischen null- und Nullwerten unterscheidet und die Optional-Klasse zur sicheren Behandlung potenziell fehlender Werte verwendet. Dies sind wichtige Konzepte für das Schreiben zuverlässigen Java-Codes.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob ein Double-Wrapper-Objekt in Java null ist. Wir haben gesehen, dass im Gegensatz zum primitiven double der Double-Typ einen null-Wert annehmen kann. Wir haben gezeigt, wie man den Vergleich == null verwendet, um das Fehlen eines Werts in einer Double-Variable zu prüfen und potenzielle NullPointerException-Fehler zu vermeiden. Wir haben auch den Unterschied zwischen einem null-Wert und einem Nullwert für ein Double-Objekt untersucht und wie man beide Fälle angemessen behandelt. Schließlich wurden wir mit der Optional-Klasse als modernem Java-Ansatz vertraut gemacht, um potenzielle null-Werte expliziter und sicherer zu behandeln.