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

Einführung

In diesem Lab werden Sie die grundlegenden Techniken zum Prüfen, ob ein Objekt in Java null ist, lernen. Dies ist eine grundlegende Fähigkeit zur Verhinderung von NullPointerException-Fehlern. Wir beginnen damit, die einfachste Methode zu untersuchen: die Verwendung des Gleichheitsoperators (==), um eine Referenzvariable direkt mit null zu vergleichen.

Basierend auf diesem Wissen werden wir dann untersuchen, wie Sie Null-Prüfungen mit Typ-Prüfungen kombinieren können, um sowohl die Existenz als auch den richtigen Typ eines Objekts sicherzustellen. Abschließend werden wir uns mit der Verwendung der Optional-Klasse befassen, einem modernen Java-Feature, das eine idiomatischere und sicherere Möglichkeit bietet, potenziell null-Werte zu behandeln und so robusteren und lesbareren Code fördert.

Gleichheitsoperator zur Null-Prüfung verwenden

In diesem Schritt werden wir eine der grundlegendsten Methoden zur Prüfung auf null in Java untersuchen: die Verwendung des Gleichheitsoperators (==). Das Verständnis, wie man null behandelt, ist in der Java-Programmierung von entscheidender Bedeutung, um Fehler zu vermeiden.

In Java ist null ein spezieller Wert, der angibt, dass eine Referenzvariable auf kein Objekt zeigt. Stellen Sie sich eine Variable als eine Box und ein Objekt als etwas vor, das Sie in die Box legen. Wenn die Box leer ist, ist die Variable null. Der Versuch, eine null-Referenz zu verwenden (wie der Versuch, etwas aus einer leeren Box zu verwenden), führt oft zu einer NullPointerException, was für Anfänger ein häufiger und frustrierender Fehler ist.

Lassen Sie uns ein einfaches Java-Programm erstellen, um zu demonstrieren, wie man mit dem Gleichheitsoperator auf null prüft.

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

Ersetzen Sie den gesamten Inhalt der Datei durch folgenden Code:

public class HelloJava {
    public static void main(String[] args) {
        String message = null; // Deklarieren einer String-Variable und Setzen auf null

        // Prüfen, ob die message-Variable null ist, indem der Gleichheitsoperator verwendet wird
        if (message == null) {
            System.out.println("The message is null.");
        } else {
            System.out.println("The message is: " + message);
        }

        message = "Hello, World!"; // Zuweisen eines String-Objekts an die Variable

        // Wiederholtes Prüfen nach der Zuweisung eines Werts
        if (message == null) {
            System.out.println("The message is null.");
        } else {
            System.out.println("The message is: " + message);
        }
    }
}

In diesem Code:

Wir deklarieren eine String-Variable namens message und setzen sie zunächst auf null.
Wir verwenden eine if-Anweisung mit dem Gleichheitsoperator (==), um zu prüfen, ob message null ist.
Wenn message == null wahr ist, geben wir "The message is null." aus.
Wenn es falsch ist, geben wir die Nachricht selbst aus.
Wir weisen dann die Zeichenkette "Hello, World!" der message-Variable zu.
Wir führen die null-Prüfung erneut durch, um die unterschiedliche Ausgabe zu sehen.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm mit dem javac-Befehl im Terminal:
```
javac HelloJava.java
```
Wenn keine Fehler auftreten, war die Kompilierung erfolgreich.
Führen Sie das kompilierte Programm mit dem java-Befehl aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
The message is null.
The message is: Hello, World!
```
Diese Ausgabe bestätigt, dass unsere null-Prüfung mit == korrekt funktioniert hat. Wenn message null war, war die erste if-Bedingung wahr. Nachdem wir einen Wert zugewiesen hatten, war die zweite if-Bedingung falsch, und der else-Block wurde ausgeführt.

Die Verwendung des Gleichheitsoperators (==) ist die Standard- und empfohlene Methode, um zu prüfen, ob eine Referenzvariable in Java null ist. Sie ist einfach, klar und effizient.

Null- und Typüberprüfungen kombinieren

In diesem Schritt werden wir lernen, wie man die Prüfung auf null mit der Prüfung des Typs eines Objekts kombiniert. Dies ist ein häufiges Szenario, wenn Sie ein Objekt erhalten und sicherstellen müssen, dass es nicht null ist und vom gewünschten Typ ist, bevor Sie es verwenden können.

Java bietet den instanceof-Operator, um zu prüfen, ob ein Objekt eine Instanz einer bestimmten Klasse ist oder ein bestimmtes Interface implementiert. Wir können dies mit unserer null-Prüfung mithilfe des logischen UND-Operators (&&) kombinieren.

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

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

Ersetzen Sie den vorhandenen Code durch folgenden:

public class HelloJava {
    public static void main(String[] args) {
        Object myObject = "This is a String"; // Deklarieren einer Object-Variable

        // Prüfen, ob myObject nicht null ist UND eine Instanz von String ist
        if (myObject != null && myObject instanceof String) {
            String message = (String) myObject; // Casten des Objekts zu einem String
            System.out.println("The object is a non-null String: " + message);
        } else {
            System.out.println("The object is null or not a String.");
        }

        myObject = null; // Setzen des Objekts auf null

        // Wiederholtes Prüfen nach dem Setzen auf null
        if (myObject != null && myObject instanceof String) {
            String message = (String) myObject;
            System.out.println("The object is a non-null String: " + message);
        } else {
            System.out.println("The object is null or not a String.");
        }

        myObject = 123; // Setzen des Objekts auf einen Integer

        // Wiederholtes Prüfen nach dem Setzen auf einen Integer
        if (myObject != null && myObject instanceof String) {
            String message = (String) myObject;
            System.out.println("The object is a non-null String: " + message);
        } else {
            System.out.println("The object is null or not a String.");
        }
    }
}

In diesem aktualisierten Code:

Wir deklarieren eine Variable myObject vom Typ Object. Object ist die Basisklasse für alle Klassen in Java, daher kann sie eine Referenz auf jedes Objekt halten.
Wir weisen zunächst einen String an myObject zu.
Die if-Bedingung myObject != null && myObject instanceof String prüft zwei Dinge:
- myObject != null: Ist die Objektreferenz nicht null?
- myObject instanceof String: Ist das Objekt eine Instanz der String-Klasse?
Der &&-Operator bedeutet, dass beide Bedingungen wahr sein müssen, damit der Code im if-Block ausgeführt wird.
Wenn beide Bedingungen wahr sind, casten wir myObject zu einem String mit (String) myObject und geben eine Nachricht aus. Das Casting ist notwendig, da myObject als Object deklariert ist und wir dem Compiler mitteilen müssen, dass wir wissen, dass es tatsächlich ein String ist, damit wir es als solchen behandeln können.
Wenn eine der Bedingungen falsch ist (das Objekt ist null oder kein String), wird der else-Block ausgeführt.
Wir testen dann die if-Bedingung, indem wir myObject auf null setzen und dann auf einen Integer (der kein String ist).

Speichern Sie die Datei.
Kompilieren Sie das Programm:
```
javac HelloJava.java
```
Führen Sie das Programm aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
The object is a non-null String: This is a String
The object is null or not a String.
The object is null or not a String.
```
Diese Ausgabe zeigt, dass die if-Bedingung korrekt erkannt hat, wann das Objekt ein nicht-null-String war und wann es entweder null oder kein String war.

Das Kombinieren von != null und instanceof ist ein Standardmuster in Java, wenn Sie sicher mit Objekten eines bestimmten Typs arbeiten müssen, die auch null sein können.

Optional zur Behandlung von Nullwerten verwenden

In diesem Schritt werden wir einen moderneren Ansatz zur Behandlung potenzieller null-Werte in Java erkunden, der mit Java 8 eingeführt wurde: die Optional-Klasse. Optional ist ein Containerobjekt, das einen nicht-null-Wert enthalten kann oder auch nicht. Es bietet eine Möglichkeit, das Vorhandensein oder Fehlen eines Werts expliziter darzustellen und so das Risiko von NullPointerExceptions zu verringern.

Die Verwendung von Optional ermutigt Sie, über die Möglichkeit des Fehlens eines Werts nachzudenken und diesen Fall elegant zu behandeln, anstatt sich auf verstreute null-Prüfungen in Ihrem Code zu verlassen.

Lassen Sie uns unser HelloJava.java-Programm ändern, um Optional zu verwenden.

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

Ersetzen Sie den vorhandenen Code durch folgenden:

import java.util.Optional;

public class HelloJava {
    public static void main(String[] args) {
        // Erstellen eines Optional, das einen Wert enthält
        Optional<String> optionalMessageWithValue = Optional.of("Hello from Optional!");

        // Erstellen eines leeren Optional (repräsentiert null)
        Optional<String> optionalMessageWithoutValue = Optional.empty();

        // Behandeln des Optional mit einem Wert
        if (optionalMessageWithValue.isPresent()) {
            String message = optionalMessageWithValue.get(); // Den Wert abrufen, wenn vorhanden
            System.out.println("Optional with value: " + message);
        } else {
            System.out.println("Optional with value is empty.");
        }

        // Behandeln des Optional ohne einen Wert
        if (optionalMessageWithoutValue.isPresent()) {
            String message = optionalMessageWithoutValue.get();
            System.out.println("Optional without value: " + message);
        } else {
            System.out.println("Optional without value is empty.");
        }

        // Eine kompaktere Möglichkeit, Optional zu behandeln, mit ifPresent
        optionalMessageWithValue.ifPresent(msg -> System.out.println("Using ifPresent: " + msg));

        // Verwenden von orElse, um einen Standardwert bereitzustellen, wenn Optional leer ist
        String messageOrDefault = optionalMessageWithoutValue.orElse("Default Message");
        System.out.println("Using orElse: " + messageOrDefault);
    }
}

In diesem Code:

Wir importieren die Optional-Klasse.
Wir erstellen ein Optional<String>, das einen Wert enthält, mit Optional.of(). Beachten Sie, dass Optional.of() eine NullPointerException wirft, wenn Sie null übergeben. Wenn der Wert null sein könnte, verwenden Sie stattdessen Optional.ofNullable().
Wir erstellen ein leeres Optional<String> mit Optional.empty().
Wir verwenden optionalMessageWithValue.isPresent(), um zu prüfen, ob das Optional einen Wert enthält. Wenn ja, können wir den Wert mit optionalMessageWithValue.get() abrufen. Vorsicht: Das Aufrufen von get() auf einem leeren Optional wirft eine NoSuchElementException.
Wir demonstrieren ähnlich die Behandlung des leeren Optional.
Wir zeigen ifPresent(), das eine gegebene Aktion nur ausführt, wenn ein Wert vorhanden ist. Dies ist eine sauberere Möglichkeit, eine Aktion auf dem Wert auszuführen, wenn er existiert.
Wir zeigen orElse(), das den Wert zurückgibt, wenn er vorhanden ist, andernfalls einen Standardwert zurückgibt. Dies ist nützlich, um Fallback-Werte bereitzustellen.

Speichern Sie die Datei.
Kompilieren Sie das Programm:
```
javac HelloJava.java
```
Führen Sie das Programm aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
Optional with value: Hello from Optional!
Optional without value is empty.
Using ifPresent: Hello from Optional!
Using orElse: Default Message
```
Diese Ausgabe zeigt, wie Optional verwendet werden kann, um das Vorhandensein oder Fehlen von Werten expliziter und sicherer zu behandeln als herkömmliche null-Prüfungen. Obwohl Optional keine vollständige Ersetzung für alle null-Prüfungen ist, ist es ein wertvolles Werkzeug für das Design von APIs und das Schreiben von Code, bei dem das Fehlen eines Werts ein gültiges und erwartetes Szenario ist.

Zusammenfassung

In diesem Lab haben wir grundlegende Techniken zum Prüfen, ob ein Objekt in Java null ist, gelernt. Wir haben begonnen, indem wir die einfachste Methode untersucht haben: die Verwendung des Gleichheitsoperators (==), um eine Referenzvariable direkt mit null zu vergleichen. Diese einfache Prüfung ist unerlässlich, um NullPointerException-Fehler zu vermeiden.

Anschließend sind wir zu fortgeschritteneren Szenarien übergegangen, obwohl der bereitgestellte Inhalt nur die grundlegende Gleichheitsüberprüfung beschreibt. Ein vollständiges Lab würde wahrscheinlich die Kombination von Null-Prüfungen mit Typ-Prüfungen sowie die Verwendung der Optional-Klasse abdecken. Dies ist ein modernes Java-Feature, das entwickelt wurde, um potenzielle Null-Werte eleganter und ausdrucksstärker zu behandeln und so saubereren und sichereren Code zu fördern.