Summary  
This chapter explains the concept of null references in Java and how failing to initialize or check objects for null before calling their methods leads to NullPointerExceptions, with preventive measures like immediate initialization and null checks.  

General domain of usage  
Handling data from external APIs (or databases)

## NPE

Compréhension du concept de la valeur ``null`` pour une variable de type chaîne. Lorsqu'une variable de chaîne est créée sans être initialisée, elle prend la valeur ``null``.
En comparaison, si une variable de type ``int`` n'est pas initialisée, elle prend la valeur ``0``.

Considération d'un exemple d'une variable de chaîne avec une valeur ``null`` :


cGFja2FnZSBjb20uZXhhbXBsZTsKCnB1YmxpYyBjbGFzcyBNYWluIHsKICAgIHB1YmxpYyBzdGF0aWMgdm9pZCBtYWluKFN0cmluZ1tdIGFyZ3MpIHsKICAgICAgICBTdHJpbmcgc3RyaW5nID0gbnVsbDsKICAgICAgICBTeXN0ZW0ub3V0LnByaW50bG4oc3RyaW5nKTsKICAgIH0KfQ==

Comme on peut le voir, la sortie affichée à l'écran est ``null``, et le code semble fonctionner. Essayons maintenant d'utiliser une méthode avec une variable ayant la valeur ``null`` :


cGFja2FnZSBjb20uZXhhbXBsZTsKCnB1YmxpYyBjbGFzcyBNYWluIHsKICAgIHB1YmxpYyBzdGF0aWMgdm9pZCBtYWluKFN0cmluZ1tdIGFyZ3MpIHsKICAgICAgICBTdHJpbmcgc3RyaW5nID0gbnVsbDsKICAgICAgICBzdHJpbmcudG9Mb3dlckNhc2UoKTsKICAgICAgICBTeXN0ZW0ub3V0LnByaW50bG4oc3RyaW5nKTsKICAgIH0KfQ==

Lorsqu'on tente d'appeler une méthode sur une variable de type chaîne ayant la valeur **null**, une ``NullPointerException`` est générée.

Méthodes pour éviter une **NPE** :

- Faire preuve de vigilance. Si une variable de type chaîne est créée, vérifier qu'elle a bien été initialisée ;
- Utiliser une **vérification de nullité** avant d'utiliser la variable, par exemple.


cGFja2FnZSBjb20uZXhhbXBsZTsKCnB1YmxpYyBjbGFzcyBNYWluIHsKICAgIHB1YmxpYyBzdGF0aWMgdm9pZCBtYWluKFN0cmluZ1tdIGFyZ3MpIHsKICAgICAgICBTdHJpbmcgc3RyaW5nID0gbnVsbDsKICAgICAgICBpZiAoc3RyaW5nID09IG51bGwpIHsgLy8gbnVsbCBjaGVjawogICAgICAgICAgICBTeXN0ZW0ub3V0LnByaW50bG4oIkNhbid0IHVzZSBtZXRob2RzIHdpdGggc3RyaW5nLCBiZWNhdXNlIHZhbHVlIGlzIG51bGwiKTsKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICBTeXN0ZW0ub3V0LnByaW50bG4oc3RyaW5nKTsKICAgICAgICB9CiAgICB9Cn0=

package com.example;

import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.TestFactory;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static org.junit.jupiter.api.Assertions.*;
import static org.junit.jupiter.api.DynamicTest.dynamicTest;

public class MainTest {

    @TestFactory
    Stream<DynamicTest> testValidateEmails() {
        List<TestCase> testCases = List.of(
                new TestCase(
                        new String[]{"alice@company.com", null, "bob@company.com", null, "charlie@company.com"},
                        new String[]{
                                "alice@company.com",
                                "Invalid or missing email",
                                "bob@company.com",
                                "Invalid or missing email",
                                "charlie@company.com"
                        },
                        "Mixed valid and null emails"
                ),
                new TestCase(
                        new String[]{null, null},
                        new String[]{"Invalid or missing email", "Invalid or missing email"},
                        "All emails are null"
                ),
                new TestCase(
                        new String[]{"noatsymbol.com", "valid@mail.com"},
                        new String[]{"Invalid or missing email", "valid@mail.com"},
                        "One email missing '@', one valid"
                )
        );

        return IntStream.range(0, testCases.size()).mapToObj(i -> {
            TestCase tc = testCases.get(i);
            String inputStr = tc.input == null ? "null" : Arrays.toString(tc.input);

            try {
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                PrintStream originalOut = System.out;
                System.setOut(new PrintStream(out));

                Main.validateEmails(tc.input);

                System.setOut(originalOut);

                String actual = out.toString().trim();
                String expected = tc.expected == null ? "" : String.join(System.lineSeparator(), tc.expected);

                String name = actual.equals(expected)
                        ? tc.description + " -> Output as expected"
                        : tc.description + " -> Output mismatch";

                return dynamicTest(name, () -> assertEquals(expected, actual));

            } catch (Exception e) {
                String name = "Runtime error: " + e.getClass().getSimpleName() +
                        " - " + e.getMessage() + " | Input: " + inputStr;
                return dynamicTest(name, () -> fail("Unexpected exception: " + e));
            }
        });
    }

    record TestCase(String[] input, String[] expected, String description) {}
}


MainTest.java

Apprenez les fondamentaux de Java et ses principales fonctionnalités dans ce cours. À la fin, vous serez capable de résoudre des tâches algorithmiques simples et d'acquérir une compréhension claire du fonctionnement des applications Java de base en console.

Découvrez les caractéristiques uniques de Java et comprenez pourquoi il s'agit d'un langage de programmation recommandé à apprendre. Écrivez votre premier code Java et explorez comment afficher du texte dans la console.

Apprenez les bases de la programmation, plongez dans les types de données primitifs et explorez les opérations associées. Écrivez du code qui effectue des tâches mathématiques et évalue des conditions pour une exécution fluide.

Explorez divers types de boucles tels que for, while et do-while, qui sont essentiels dans tout langage de programmation. Les boucles permettent une itération efficace sur de grands ensembles de données, économisant ainsi un temps considérable. Leur application est fréquente dans des tâches telles que le tri, la manipulation de tableaux, de collections, et bien plus encore.

Apprenez à utiliser efficacement les tableaux en programmation Java en découvrant comment regrouper des données dans des tableaux et en explorant les méthodes et propriétés courantes pour les manipuler. Les techniques de manipulation et d’optimisation des tableaux dans des applications réelles seront également examinées.

Découvrez le type de données String, essentiel en Java, et explorez ses nombreuses méthodes et opérations intégrées. Étudiez String et StringBuilder, en comprenant leurs méthodes de base et comment utiliser efficacement les chaînes de caractères en Java.

Exception NullPointer

NPE

Solution