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

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un objet Double est nul en Java. Nous explorerons la différence entre le type primitif double et la classe wrapper Double, ainsi que la manière de gérer les erreurs potentielles de NullPointerException.

Le laboratoire vous guidera tout au long de la vérification de la nullité à l'aide de l'opérateur d'égalité, de la distinction entre les valeurs nulles et les valeurs zéro, et de l'utilisation de la classe Optional pour une gestion plus robuste des valeurs nulles. Vous implémenterez et testerez des exemples de code pour consolider votre compréhension de ces concepts.

Vérifier si le wrapper Double est null

Dans cette étape, nous allons explorer comment gérer les objets wrapper Double en Java, en particulier en vérifiant si une variable de type Double est null. Contrairement aux types primitifs comme double, les classes wrapper comme Double peuvent contenir une valeur null, qui représente l'absence de valeur. Il est crucial de gérer correctement les valeurs null pour éviter les erreurs de NullPointerException dans vos programmes.

Créons un simple programme Java pour démontrer la vérification de la nullité d'un objet Double.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE. Si vous ne l'avez pas ouvert, vous le trouverez dans l'explorateur de fichiers à gauche, sous le répertoire ~/project.
Remplacez le code existant dans HelloJava.java par le code suivant :
```
public class HelloJava {
    public static void main(String[] args) {
        Double price = null; // Déclare une variable Double et l'initialise à 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; // Déclare une autre variable Double et lui attribue une valeur

        if (quantity == null) {
            System.out.println("Quantity is not set (it is null).");
        } else {
            System.out.println("Quantity is set to: " + quantity);
        }
    }
}
```
Examinons les nouvelles parties de ce code :
- Double price = null; : Nous déclarons une variable nommée price de type Double et lui assignons la valeur null.
- if (price == null) : Il s'agit d'une instruction if qui vérifie si la variable price est égale à null. L'opérateur == est utilisé pour comparer si la référence à l'objet est null.
- System.out.println("Price is not set (it is null)."); : Cette ligne sera exécutée si price est effectivement null.
- Double quantity = 10.5; : Nous déclarons une autre variable Double nommée quantity et lui assignons une valeur numérique.
- La deuxième instruction if vérifie si quantity est null. Étant donné que nous lui avons assigné une valeur, cette condition sera fausse.
Enregistrez le fichier HelloJava.java (Ctrl+S ou Cmd+S).
Maintenant, compilez le programme modifié. Ouvrez le terminal en bas de l'éditeur WebIDE et exécutez la commande suivante :
```
javac HelloJava.java
```
Si la compilation réussit, vous ne verrez aucun message de sortie.
Enfin, exécutez le programme compilé :
```
java HelloJava
```
Vous devriez voir la sortie suivante :
```
Price is not set (it is null).
Quantity is set to: 10.5
```
Cette sortie confirme que notre programme a correctement identifié que price était null et que quantity avait une valeur.

Comprendre comment vérifier la nullité est fondamental lorsque vous travaillez avec des objets Java, en particulier les classes wrapper. Dans l'étape suivante, nous explorerons la différence entre un Double null et un Double avec une valeur de zéro.

Gérer les valeurs nulles par rapport aux valeurs zéro

Dans l'étape précédente, nous avons appris à vérifier si un objet wrapper Double est null. Maintenant, explorons la différence entre un Double qui est null et un Double qui a une valeur de zéro (0.0). Cette distinction est importante car null signifie "aucune valeur", tandis que 0.0 est une valeur numérique spécifique.

Imaginons un scénario où vous suivez la remise appliquée à un produit. Une remise null pourrait signifier que les informations sur la remise ne sont pas disponibles, tandis qu'une remise de 0.0 signifie qu'aucune remise n'est explicitement appliquée.

Modifions notre programme HelloJava.java pour démontrer cette différence.

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

Remplacez le code existant par le code suivant :

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);
        }
    }
}

Dans ce code mis à jour :

Nous introduisons trois variables Double : discount (initialisée à null), zeroDiscount (initialisée à 0.0) et appliedDiscount (initialisée à 5.5).
Nous utilisons une structure if-else if-else pour vérifier l'état de chaque variable :
- Tout d'abord, nous vérifions si la variable est null.
- Si elle n'est pas null, nous vérifions ensuite si sa valeur est 0.0.
- Sinon, nous supposons qu'une valeur de remise spécifique est appliquée.

Enregistrez le fichier HelloJava.java.
Compilez le programme dans le terminal :
```
javac HelloJava.java
```
Exécutez le programme compilé :
```
java HelloJava
```
Vous devriez voir la sortie suivante :
```
Discount information is not available (it is null).
---
There is no discount (value is 0.0).
---
Discount applied: 5.5
```
Cette sortie montre clairement comment Java distingue entre un Double null et un Double avec une valeur de 0.0. Gérer correctement ces cas est essentiel pour écrire des applications Java robustes.

Dans l'étape suivante, nous explorerons une approche plus moderne pour gérer les valeurs null potentielles en utilisant la classe Optional, qui peut rendre votre code plus sûr et plus lisible.

Tester avec la classe Optional

En Java moderne (Java 8 et versions ultérieures), la classe Optional est souvent utilisée pour représenter une valeur qui peut être présente ou non. Cela offre un moyen plus explicite et plus sûr de gérer les valeurs null potentielles par rapport à l'utilisation simple de références null. L'utilisation de Optional peut aider à prévenir les erreurs de NullPointerException et rendre votre code plus lisible.

Réécrivons notre exemple de remise en utilisant la classe Optional<Double>.

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

Remplacez le code existant par le code suivant :

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);
    }
}

Examinons les principales modifications :

import java.util.Optional; : Nous importons la classe Optional.
Optional<Double> optionalDiscount = Optional.empty(); : Nous créons un Optional<Double> vide, représentant l'absence de valeur de remise.
Optional<Double> optionalZeroDiscount = Optional.of(0.0); : Nous créons un Optional<Double> contenant la valeur 0.0. Optional.of() est utilisé lorsque vous êtes sûr que la valeur n'est pas null.
Optional<Double> optionalAppliedDiscount = Optional.of(5.5); : Nous créons un Optional<Double> contenant la valeur 5.5.
optionalDiscount.isPresent() : Cette méthode vérifie si l'Optional contient une valeur. C'est la méthode recommandée pour vérifier au lieu de comparer à null.
optionalDiscount.get() : Cette méthode récupère la valeur de l'Optional. Attention : Si l'Optional est vide, l'appel de get() lancera une NoSuchElementException. Vérifiez toujours isPresent() avant d'appeler get(), ou utilisez des méthodes alternatives comme orElse().
optionalDiscount.orElse(0.0) : Cette méthode renvoie la valeur à l'intérieur de l'Optional si elle est présente ; sinon, elle renvoie la valeur par défaut fournie (dans ce cas, 0.0). C'est un moyen sûr d'obtenir une valeur et de gérer le cas où l'Optional est vide.

Enregistrez le fichier HelloJava.java.
Compilez le programme dans le terminal :
```
javac HelloJava.java
```
Exécutez le programme compilé :
```
java HelloJava
```
Vous devriez voir la sortie suivante :
```
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
```
Cette sortie démontre comment Optional nous aide à gérer explicitement les cas où une valeur peut manquer. L'utilisation de Optional peut conduire à un code plus propre et plus robuste en réduisant le risque de NullPointerException.

Vous avez maintenant appris à vérifier la nullité dans les objets wrapper Double, à différencier les valeurs null et les valeurs zéro, et à utiliser la classe Optional pour gérer plus sûrement les valeurs potentiellement manquantes. Ce sont des concepts importants pour écrire un code Java fiable.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si un objet wrapper Double en Java est null. Nous avons vu que contrairement au type primitif double, Double peut contenir une valeur null. Nous avons démontré comment utiliser la comparaison == null pour vérifier l'absence de valeur dans une variable Double et prévenir les erreurs potentielles de NullPointerException. Nous avons également exploré la différence entre une valeur null et une valeur zéro pour un objet Double et comment gérer correctement les deux cas. Enfin, nous avons été présentés à la classe Optional comme une approche moderne en Java pour gérer plus explicitement et plus sûrement les valeurs nulles potentielles.