Pause café #98. Nouvelle exception Nullpointer dans Java 17. Que signifie en Java ?

Nouvelle exception Nullpointer dans Java 17

Source : Dev.to Chaque développeur Java doit connaître l'existence d'une nouvelle exception Nullpointer ou NPE dans Java 17. C’est une de ces situations que vous devriez toujours essayer de prévenir. Parfois, Nullpointer signifie que vous devez déboguer votre code pour trouver un petit bug. Un NPE est une exception d'exécution qui se produit lorsque votre code souhaite utiliser un objet ou une référence à un objet ayant une valeur nulle. Cela peut se produire si aucune valeur n’est attribuée ou si l’objet n’a pas de référence. Avant la dernière version d'OpenJDK (version 17), une exception Nullpointer normale dans la trace de la pile ressemblerait à ceci :

java.lang.NullPointerException: null

Bien entendu, ce n’est pas tout ce que vous devez savoir sur les traces de pile. Comme vous pouvez le constater, cela n’indique ni où ni pourquoi cette exception s’est produite. Découvrez comment Java 17 résout ce problème :

Exception in thread "main" java.lang.NullPointerException:
Cannot assign field "i" because "a" is null
at Prog.main(Prog.java:5)

Dans cet exemple, l'exception indique où et quelle se trouve notre référence d'objet nul. C'est si simple!

Que signifie <T> en Java ?

Source : Dev.to <T> est une lettre courante qui signifie « Type » et fait référence au concept générique en Java. Vous pouvez utiliser une autre lettre pour cela, mais comme vous pouvez le constater, la lettre T est préférable.

Qu’est-ce que le générique ?

Générique est un moyen de paramétrer une classe, une méthode ou une interface. Regardons un exemple de générique :

package Generics;

class House<T>{

    T doorNumber;

    public House(T doorNumber) {
        this.doorNumber = doorNumber;
    }

    public void print(){
        System.out.println("Your house number is: " + this.doorNumber);
    }
}

• Nous avons une classe appelée House qui peut accepter un type d'objet arbitraire.
• Nous avons ensuite un champ appelé doorNumber , qui peut également accepter n'importe quel type d'objet.
• À la fin, nous déclarons un constructeur paramétré et imprimons le numéro de porte.

En termes simples, l'utilisateur peut décider si ce nombre est Integer, String, Float, etc. REMARQUE : vous ne pouvez utiliser que des Objects . Les types primitifs ne sont pas pris en charge car les génériques sont destinés à être utilisés au moment de la compilation. Lorsque nous utilisons Generics, T remplace tout ce qui peut étendre la classe Object , et les primitives n'ont pas cette propriété. Disons que nous voulons que doorNumber soit une chaîne.

public class GenericsExample {
    public static void main(String[] args) {
        House<String> mainHouse = new House<>("14a");
        mainHouse.print();

    }
}

Le résultat ressemblera à ceci : Nous remplacerons la lettre « T » par « String » et saisirons le numéro de la maison dans le constructeur. Nous pouvons utiliser plusieurs types si, par exemple, nous avons besoin qu’une classe accepte plus d’un objet. On peut ajouter une autre lettre et ainsi dire : on veut que la classe accepte un autre Générique.

package Generics;

class House<T, V>{

    T doorNumber;
    V streetName;

    public House(T doorNumber, V streetName) {
        this.doorNumber = doorNumber;
        this.streetName = streetName;
    }

    public void print(){
        System.out.println("You live at: " + this.doorNumber + " " + this.streetName);
    }
}

public class GenericsExample {
    public static void main(String[] args) {
        House<Integer, String> mainHouse = new House<>(14, "Tellson Avenue");
        mainHouse.print();

    }
}

Le résultat sera comme ceci : Jusqu'à présent, nous avons vu des exemples d'utilisation de Generic au niveau de la classe. Mais nous pouvons aussi avoir des méthodes et des interfaces communes.

Méthode générique

package Generics;

class House{

    public <T> void print(T doorNumber){
        System.out.println("You live at house number: " + doorNumber);
    }

}

public class GenericsExample {
    public static void main(String[] args) {
        House mainHouse = new House();
        mainHouse.<Integer>print(14);

    }
}

La méthode accepte tout type d'objet et génère le numéro de porte, qui sera n'importe quel type d' Object . Dans ce cas, nous voulons que la méthode accepte un entier. Le résultat sera :

Interface générique

Créez d’abord l’interface.

package Generics;

interface Property<T>{
    void hasBalcony(T balcony);
}

Implémentez ensuite l’interface.

package Generics;

public class House implements Property<String> {

    @Override
    public void hasBalcony(String balcony) {
        System.out.println("Is there a balcony in the room? " + balcony);
    }

    public static void main(String[] args) {
        House mainHouse = new House();
        mainHouse.hasBalcony("YES");
    }

}

Résultat: Quels sont les avantages d’utiliser des génériques ?

1. Meilleure vérification au moment de la compilation : si vous utilisez un type d'objet autre que celui que vous avez spécifié, le compilateur vous le dira.
2. Réutilisabilité : vous pouvez utiliser une classe, une méthode ou une interface plusieurs fois car vous décidez quel type d'objet utiliser en fonction de ce que vous essayez d'atteindre.
3. C'est idéal pour les structures de données et les algorithmes : ArrayList et HashMap ne sont que quelques exemples d'utilisation de Generic.