Comment vérifier si un objet Character est null en Java

Introduction

Dans ce laboratoire (lab), nous allons explorer comment gérer les valeurs potentiellement null lorsque nous travaillons avec la classe wrapper Character de Java. Contrairement au type primitif char, l'objet Character peut être null, et ne pas gérer ce cas peut entraîner des erreurs de NullPointerException. Nous allons apprendre à vérifier si un objet Character est null, à combiner des vérifications de nullité avec d'autres vérifications de propriétés de caractères, et à utiliser la classe Optional pour une gestion plus sûre des valeurs null.

Grâce à des exemples pratiques, vous aurez l'opportunité d'acquérir une expérience pratique dans l'écriture de code Java robuste qui gère efficacement les objets Character null, en évitant les erreurs courantes à l'exécution et en améliorant la fiabilité de vos applications.

Vérifier si le wrapper Character est null

Dans cette étape, nous allons explorer comment gérer les valeurs potentiellement null lorsque nous travaillons avec la classe wrapper Character de Java. Alors que les types primitifs char ne peuvent pas être null, la classe wrapper Character, étant un objet, peut l'être. Gérer les valeurs null est crucial pour éviter les erreurs de NullPointerException, qui sont courantes en Java et peuvent faire planter votre programme.

Nous allons commencer par créer un simple programme Java qui montre comment une NullPointerException peut se produire lorsque vous essayez d'utiliser une méthode sur un objet Character qui est null.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE s'il n'est pas déjà ouvert.
Remplacez tout le contenu du fichier par le code suivant :
```
public class HelloJava {
    public static void main(String[] args) {
        Character myChar = null;

        // Cette ligne causera une NullPointerException si myChar est null
        // System.out.println("Is myChar a letter? " + Character.isLetter(myChar));
    }
}
```
Dans ce code :
- Nous déclarons une variable Character nommée myChar et la définissons explicitement sur null.
- La ligne commentée System.out.println("Is myChar a letter? " + Character.isLetter(myChar)); tente d'appeler la méthode statique Character.isLetter() avec un argument null. Bien que Character.isLetter() soit une méthode statique, passer un objet Character null à cette méthode entraînera toujours une NullPointerException car la méthode tente en interne de convertir l'objet Character en sa valeur primitive char, ce qui n'est pas possible pour null.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Maintenant, compilons le programme. Ouvrez le terminal en bas de l'éditeur WebIDE et exécutez la commande suivante :
```
javac HelloJava.java
```
Vous ne devriez voir aucun message de sortie si la compilation réussit.
Maintenant, essayons d'exécuter le programme. Dans le terminal, exécutez la commande suivante :
```
java HelloJava
```
Étant donné que la ligne qui causerait l'erreur est commentée, le programme s'exécutera sans aucun message de sortie ni d'erreur. Cela montre que simplement déclarer un Character comme null ne cause pas de problème immédiat ; le problème apparaît lorsque vous essayez d'effectuer des opérations sur cet objet.

Dans l'étape suivante, nous allons décommenter la ligne problématique et observer la NullPointerException.

Combiner les vérifications de nullité et de lettre

Dans l'étape précédente, nous avons vu comment une NullPointerException peut se produire lorsque nous travaillons avec des objets Character. Maintenant, décommentez la ligne qui cause l'erreur et voyez l'exception en action. Ensuite, nous allons apprendre une méthode courante pour éviter cela en combinant une vérification de nullité avec la vérification de lettre.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

Décommentez la ligne qui appelle Character.isLetter(). Votre code devrait maintenant ressembler à ceci :

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

        // Cette ligne causera une NullPointerException si myChar est null
        System.out.println("Is myChar a letter? " + Character.isLetter(myChar));
    }
}

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié dans le terminal :
```
javac HelloJava.java
```
Encore une fois, vous ne devriez voir aucun message de sortie si la compilation réussit.
Maintenant, exécutez le programme :
```
java HelloJava
```
Vous devriez voir une sortie similaire à ceci, indiquant une NullPointerException :
```
Exception in thread "main" java.lang.NullPointerException
    at java.base/java.lang.Character.isLetter(Character.java:xxxx)
    at HelloJava.main(HelloJava.java:x)
```
Cette erreur se produit car myChar est null, et la méthode Character.isLetter() ne peut pas opérer sur un objet null.
Pour éviter cette NullPointerException, nous pouvons ajouter une vérification pour voir si myChar est null avant d'essayer d'appeler Character.isLetter(). Nous pouvons utiliser une instruction if pour cela. Modifiez votre fichier HelloJava.java pour inclure cette vérification :
```
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.");
        }
    }
}
```
Dans ce code mis à jour :
- Nous utilisons une instruction if avec deux conditions combinées par && (l'opérateur logique ET).
- La première condition, myChar != null, vérifie si myChar n'est pas null.
- La deuxième condition, Character.isLetter(myChar), vérifie si myChar est une lettre.
- L'opérateur && est "court-circuitant". Cela signifie que si la première condition (myChar != null) est fausse, la deuxième condition (Character.isLetter(myChar)) n'est pas évaluée. Cela évite la NullPointerException car nous essayons d'appeler Character.isLetter() seulement si myChar n'est pas null.
Enregistrez le fichier.
Compilez le programme à nouveau :
```
javac HelloJava.java
```
Exécutez le programme :
```
java HelloJava
```
Cette fois, le programme devrait s'exécuter sans erreur et afficher :
```
myChar is not a letter or is null.
```
C'est parce que myChar est null, donc la première condition dans l'instruction if (myChar != null) est fausse, et le bloc else est exécuté.

Cette approche consistant à vérifier la nullité avant d'accéder aux méthodes ou propriétés d'un objet est une technique fondamentale en Java pour éviter les NullPointerException.

Utiliser Optional pour la sécurité vis-à-vis des valeurs nulles

Dans l'étape précédente, nous avons appris à éviter les NullPointerException en vérifiant explicitement si un objet est null avant de l'utiliser. Bien que cette méthode soit efficace, elle peut parfois entraîner un code encombré de vérifications de nullité. Java 8 a introduit la classe Optional pour gérer les valeurs potentiellement nulles d'une manière plus fonctionnelle et expressive.

Optional est un objet conteneur qui peut contenir une valeur non nulle ou être vide. Si une valeur est présente, isPresent() retourne true et get() retourne la valeur. Si aucune valeur n'est présente, l'objet est considéré comme vide et isPresent() retourne false. Appeler get() sur un Optional vide lance une NoSuchElementException.

Refactorisons notre exemple pour utiliser Optional<Character> afin de gérer la possibilité d'un Character null.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

Remplacez tout le contenu du fichier par le code suivant :

import java.util.Optional;

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

        // Crée un Optional à partir du Character potentiellement null
        Optional<Character> optionalChar = Optional.ofNullable(myChar);

        // Utilise les méthodes d'Optional pour vérifier et traiter la valeur
        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.");
        }

        // Une autre façon en utilisant les méthodes fonctionnelles d'Optional (plus avancé)
        // 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).")
        //             );
    }
}

Dans ce code :

Nous importons la classe Optional.
Nous déclarons toujours myChar comme potentiellement null.
Optional<Character> optionalChar = Optional.ofNullable(myChar); crée un objet Optional. Optional.ofNullable() est utilisé lorsque la valeur peut être null. Si myChar est null, optionalChar sera un Optional vide. Si myChar a une valeur, optionalChar contiendra cette valeur.
Nous utilisons ensuite optionalChar.isPresent() pour vérifier si l'Optional contient une valeur avant d'essayer de la récupérer avec optionalChar.get() et de la passer à Character.isLetter(). Cela est similaire à notre vérification de nullité précédente, mais utilise l'API Optional.
La section commentée montre une façon plus avancée d'utiliser Optional avec des méthodes fonctionnelles telles que filter et ifPresentOrElse, qui peuvent rendre le code plus concis dans certains scénarios. Nous ne nous concentrerons pas sur cette utilisation avancée dans ce laboratoire introductif, mais il est bon d'en être conscient.

Enregistrez le fichier.
Compilez le programme :
```
javac HelloJava.java
```
Exécutez le programme :
```
java HelloJava
```
La sortie devrait être la même que dans l'étape précédente :
```
myChar is not a letter or is null.
```
Cela confirme que l'utilisation de Optional.ofNullable() et de isPresent() gère correctement le cas où la valeur est null.

Maintenant, modifions myChar pour qu'il soit un caractère non null afin de voir comment le programme se comporte.

Modifiez le fichier HelloJava.java pour définir myChar sur un caractère, par exemple, 'A' :

import java.util.Optional;

public class HelloJava {
    public static void main(String[] args) {
        Character myChar = 'A'; // Maintenant myChar a une valeur

        // Crée un Optional à partir du Character potentiellement null
        Optional<Character> optionalChar = Optional.ofNullable(myChar);

        // Utilise les méthodes d'Optional pour vérifier et traiter la valeur
        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.");
        }
    }
}

Enregistrez le fichier.
Compilez le programme :
```
javac HelloJava.java
```
Exécutez le programme :
```
java HelloJava
```
Cette fois, la sortie devrait être :
```
myChar is a letter.
```
Cela montre que lorsque myChar a une valeur, optionalChar.isPresent() retourne true et la vérification Character.isLetter() est effectuée correctement.

L'utilisation de Optional peut rendre votre code plus lisible et indiquer explicitement lorsqu'une valeur peut être absente, réduisant ainsi la probabilité de NullPointerException inattendues.

Résumé

Dans ce laboratoire, nous avons appris à gérer les valeurs potentiellement null lorsque nous travaillons avec la classe wrapper Character en Java. Nous avons commencé par montrer comment une NullPointerException peut se produire lorsqu'on essaie d'utiliser une méthode sur un objet Character null, même avec des méthodes statiques telles que Character.isLetter(). Cela a mis en évidence l'importance de vérifier explicitement la nullité avant d'effectuer des opérations sur les objets Character pour éviter les plantages du programme.