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

Einführung

In diesem Lab werden wir untersuchen, wie man potenzielle null-Werte behandelt, wenn man mit Java's Character-Wrapperklasse arbeitet. Im Gegensatz zum primitiven char-Typ kann das Character-Objekt null sein, und wenn man dies nicht behandelt, kann dies zu NullPointerException-Fehlern führen. Wir werden lernen, wie man prüft, ob ein Character-Objekt null ist, Null-Prüfungen mit anderen Zeichen-Eigenschaftsprüfungen kombiniert und die Optional-Klasse für eine sicherere Null-Behandlung nutzt.

Durch praktische Beispiele werden Sie praktische Erfahrungen beim Schreiben robuster Java-Code sammeln, der effektiv null-Character-Objekte verwaltet, häufige Laufzeitfehler verhindert und die Zuverlässigkeit Ihrer Anwendungen verbessert.

Prüfen Sie den Character-Wrapper auf Null

In diesem Schritt werden wir untersuchen, wie man potenzielle null-Werte behandelt, wenn man mit Java's Character-Wrapperklasse arbeitet. Während primitive char-Typen nicht null sein können, kann die Character-Wrapperklasse als Objekt null sein. Die Behandlung von null-Werten ist entscheidend, um NullPointerException-Fehler zu vermeiden, die in Java häufig auftreten und Ihr Programm zum Absturz bringen können.

Wir beginnen mit der Erstellung eines einfachen Java-Programms, das zeigt, wie eine NullPointerException auftreten kann, wenn Sie versuchen, eine Methode auf einem Character-Objekt aufzurufen, das null ist.

Ö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) {
        Character myChar = null;

        // Diese Zeile verursacht eine NullPointerException, wenn myChar null ist
        // System.out.println("Is myChar a letter? " + Character.isLetter(myChar));
    }
}
```
In diesem Code:
- Wir deklarieren eine Character-Variable namens myChar und setzen sie explizit auf null.
- Die auskommentierte Zeile System.out.println("Is myChar a letter? " + Character.isLetter(myChar)); versucht, die statische Methode Character.isLetter() mit einem null-Argument aufzurufen. Obwohl Character.isLetter() eine statische Methode ist, führt das Übergeben eines null-Character-Objekts immer noch zu einer NullPointerException, da die Methode intern versucht, das Character-Objekt in seinen primitiven char-Wert zu entpacken, was für null nicht möglich ist.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Jetzt lassen wir das Programm kompilieren. Öffnen Sie das Terminal am unteren Rand des WebIDE und führen Sie aus:
```
javac HelloJava.java
```
Wenn die Kompilierung erfolgreich ist, sollten Sie keine Ausgabe sehen.
Jetzt versuchen wir, das Programm auszuführen. Im Terminal führen Sie aus:
```
java HelloJava
```
Da die Zeile, die den Fehler verursachen würde, auskommentiert ist, wird das Programm ohne Ausgabe oder Fehler ausgeführt. Dies zeigt, dass das einfache Deklarieren eines Character als null keine sofortige Probleme verursacht; das Problem tritt auf, wenn Sie versuchen, Operationen darauf auszuführen.

Im nächsten Schritt werden wir die problematische Zeile einkommentieren und die NullPointerException beobachten.

Kombinieren Sie Null- und Buchstabenprüfungen

Im vorherigen Schritt haben wir gesehen, wie eine NullPointerException auftreten kann, wenn man mit Character-Objekten arbeitet. Jetzt lassen wir die Zeile, die den Fehler verursacht, einkommentieren und sehen die Ausnahme in Aktion. Dann lernen wir eine gängige Methode, um dies zu verhindern, indem wir eine Null-Prüfung mit der Buchstabenprüfung kombinieren.

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

Entfernen Sie die Kommentierung der Zeile, die Character.isLetter() aufruft. Ihr Code sollte jetzt so aussehen:

public class HelloJava {
    public static void main(String[] args) {
        Character myChar = null;

        // Diese Zeile verursacht eine NullPointerException, wenn myChar null ist
        System.out.println("Is myChar a letter? " + Character.isLetter(myChar));
    }
}

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac HelloJava.java
```
Wieder sollten Sie keine Ausgabe sehen, wenn die Kompilierung erfolgreich ist.
Jetzt führen Sie das Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen, die auf eine NullPointerException hinweist:
```
Exception in thread "main" java.lang.NullPointerException
    at java.base/java.lang.Character.isLetter(Character.java:xxxx)
    at HelloJava.main(HelloJava.java:x)
```
Dieser Fehler tritt auf, weil myChar null ist und die Methode Character.isLetter() nicht auf ein null-Objekt angewendet werden kann.
Um diese NullPointerException zu verhindern, können wir eine Prüfung hinzufügen, um zu sehen, ob myChar null ist, bevor wir versuchen, Character.isLetter() aufzurufen. Wir können dafür eine if-Anweisung verwenden. Ändern Sie Ihre HelloJava.java-Datei, um diese Prüfung einzubeziehen:
```
public class HelloJava {
    public static void main(String[] args) {
        Character myChar = null;

        if (myChar != null && Character.isLetter(myChar)) {
            System.out.println("myChar is a letter.");
        } else {
            System.out.println("myChar is not a letter or is null.");
        }
    }
}
```
In diesem aktualisierten Code:
- Wir verwenden eine if-Anweisung mit zwei Bedingungen, die durch && (den logischen UND-Operator) kombiniert sind.
- Die erste Bedingung, myChar != null, prüft, ob myChar nicht null ist.
- Die zweite Bedingung, Character.isLetter(myChar), prüft, ob myChar ein Buchstabe ist.
- Der &&-Operator ist "kurzschlussfähig". Das bedeutet, dass wenn die erste Bedingung (myChar != null) falsch ist, die zweite Bedingung (Character.isLetter(myChar)) nicht ausgewertet wird. Dies verhindert die NullPointerException, weil wir nur versuchen, Character.isLetter() aufzurufen, wenn myChar nicht null ist.
Speichern Sie die Datei.
Kompilieren Sie das Programm erneut:
```
javac HelloJava.java
```
Führen Sie das Programm aus:
```
java HelloJava
```
Diesmal sollte das Programm ohne Fehler laufen und ausgeben:
```
myChar is not a letter or is null.
```
Dies liegt daran, dass myChar null ist, also ist die erste Bedingung in der if-Anweisung (myChar != null) falsch, und der else-Block wird ausgeführt.

Dieser Ansatz, auf null zu prüfen, bevor man auf die Methoden oder Eigenschaften eines Objekts zugreift, ist eine grundlegende Technik in Java, um NullPointerExceptions zu vermeiden.

Verwenden Sie Optional für Null-Sicherheit

Im vorherigen Schritt haben wir gelernt, wie man NullPointerException verhindern kann, indem man explizit prüft, ob ein Objekt null ist, bevor man es verwendet. Obwohl dies effektiv ist, kann es manchmal zu Code führen, der mit Null-Prüfungen überfüllt ist. Java 8 hat die Optional-Klasse eingeführt, um potenziell null-Werte auf eine funktionalere und ausdrucksstärkere Weise zu behandeln.

Optional ist ein Containerobjekt, das einen nicht-null-Wert enthalten kann oder auch nicht. Wenn ein Wert vorhanden ist, gibt isPresent() true zurück und get() gibt den Wert zurück. Wenn kein Wert vorhanden ist, wird das Objekt als leer angesehen und isPresent() gibt false zurück. Das Aufrufen von get() auf einem leeren Optional löst eine NoSuchElementException aus.

Lassen Sie uns unser Beispiel umgestalten, um Optional<Character> zu verwenden, um die Möglichkeit eines null-Character zu behandeln.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Ersetzen Sie den gesamten Inhalt der Datei durch folgenden Code:
```
import java.util.Optional;

public class HelloJava {
    public static void main(String[] args) {
        Character myChar = null; // Noch immer potenziell null

        // Erstellen Sie ein Optional aus dem potenziell null Character
        Optional<Character> optionalChar = Optional.ofNullable(myChar);

        // Verwenden Sie Optional-Methoden, um den Wert zu prüfen und zu verarbeiten
        if (optionalChar.isPresent() && Character.isLetter(optionalChar.get())) {
             System.out.println("myChar is a letter.");
        } else {
             System.out.println("myChar is not a letter or is null.");
        }

        // Eine andere Möglichkeit unter Verwendung von Optional's funktionalen Methoden (fortgeschrittener)
        // optionalChar.filter(Character::isLetter)
        //             .ifPresentOrElse(
        //                 c -> System.out.println("myChar is a letter (using Optional methods)."),
        //                 () -> System.out.println("myChar is not a letter or is null (using Optional methods).")
        //             );
    }
}
```
In diesem Code:
- Wir importieren die Optional-Klasse.
- Wir deklarieren immer noch myChar als potenziell null.
- Optional<Character> optionalChar = Optional.ofNullable(myChar); erstellt ein Optional-Objekt. Optional.ofNullable() wird verwendet, wenn der Wert null sein könnte. Wenn myChar null ist, wird optionalChar ein leeres Optional sein. Wenn myChar einen Wert hat, wird optionalChar diesen Wert enthalten.
- Wir verwenden dann optionalChar.isPresent(), um zu prüfen, ob das Optional einen Wert enthält, bevor wir versuchen, ihn mit optionalChar.get() zu erhalten und ihn an Character.isLetter() zu übergeben. Dies ist ähnlich wie unsere vorherige Null-Prüfung, verwendet jedoch die Optional-API.
- Der auskommentierte Abschnitt zeigt eine fortgeschrittenere Möglichkeit, Optional mit funktionalen Methoden wie filter und ifPresentOrElse zu verwenden, was den Code für bestimmte Szenarien kompakter machen kann. Wir werden uns in diesem Einführungslabor nicht auf diese fortgeschrittene Verwendung konzentrieren, aber es ist gut, sich dessen bewusst zu sein.
Speichern Sie die Datei.
Kompilieren Sie das Programm:
```
javac HelloJava.java
```
Führen Sie das Programm aus:
```
java HelloJava
```
Die Ausgabe sollte die gleiche wie im vorherigen Schritt sein:
```
myChar is not a letter or is null.
```
Dies bestätigt, dass die Verwendung von Optional.ofNullable() und isPresent() den Null-Fall korrekt behandelt.

Jetzt ändern wir myChar in ein nicht-null-Zeichen, um zu sehen, wie das Programm verhält.

Ändern Sie die HelloJava.java-Datei, um myChar auf ein Zeichen, zum Beispiel 'A', zu setzen:

import java.util.Optional;

public class HelloJava {
    public static void main(String[] args) {
        Character myChar = 'A'; // Jetzt hat myChar einen Wert

        // Erstellen Sie ein Optional aus dem potenziell null Character
        Optional<Character> optionalChar = Optional.ofNullable(myChar);

        // Verwenden Sie Optional-Methoden, um den Wert zu prüfen und zu verarbeiten
        if (optionalChar.isPresent() && Character.isLetter(optionalChar.get())) {
             System.out.println("myChar is a letter.");
        } else {
             System.out.println("myChar is not a letter or is null.");
        }
    }
}

Speichern Sie die Datei.
Kompilieren Sie das Programm:
```
javac HelloJava.java
```
Führen Sie das Programm aus:
```
java HelloJava
```
Diesmal sollte die Ausgabe sein:
```
myChar is a letter.
```
Dies zeigt, dass wenn myChar einen Wert hat, optionalChar.isPresent() true zurückgibt und die Character.isLetter()-Prüfung korrekt durchgeführt wird.

Die Verwendung von Optional kann Ihren Code lesbarer machen und deutlich anzeigen, wann ein Wert fehlen kann, wodurch die Wahrscheinlichkeit unerwarteter NullPointerExceptions verringert wird.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man potenzielle null-Werte behandelt, wenn man mit der Character-Wrapper-Klasse in Java arbeitet. Wir haben begonnen, indem wir gezeigt haben, wie eine NullPointerException auftreten kann, wenn man versucht, eine Methode auf einem null-Character-Objekt anzuwenden, selbst bei statischen Methoden wie Character.isLetter(). Dies hat die Wichtigkeit einer expliziten Prüfung auf null vor der Ausführung von Operationen auf Character-Objekten hervorgehoben, um Programmabstürze zu vermeiden.