26. Le type brut ne doit pas être utilisé

Le type brut fait référence à un type générique déclaré sans paramètre de type. Par exemple, pour List , quelque chose comme List est appelé un type brut.
Lors de l'utilisation du type brut, les erreurs qui pourraient être détectées au moment de la compilation si le type générique est déclaré avec les paramètres de type clarifiés ne seront pas détectées avant l'exécution.

package tryAny.effectiveJava;

import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

public class GenericsTest1 {

    public static void main(String[] args) {
        final Collection stamps = Arrays.asList(new Stamp(), new Stamp(), "");
        //Le code suivant le détectera comme une erreur de compilation.
        // final Collection<Stamp> stamps = Arrays.asList(new Stamp(), new Stamp(), "");
        for (Iterator i = stamps.iterator(); i.hasNext();) {
            Stamp stamp = (Stamp) i.next(); //Envoyer une erreur lors de la diffusion du troisième élément. Uniquement connu au moment de l'exécution.
            System.out.println("cast success");
        }
    }

    static class Stamp {

    }
}

Vous ne devez pas utiliser de types bruts comme List, mais vous pouvez utiliser des types génériques comme List
qui autorisent n'importe quel type. D'une manière générale, la différence entre les deux est que le premier n'est pas génériquement adapté, tandis que le second permet explicitement au compilateur d'accepter n'importe quel type. Par exemple, List
peut être de type List, mais pas de List
.
```
package tryAny.effectiveJava;

import java.util.ArrayList;
import java.util.List;

public class GenericsTest2 {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        unsafeAdd(strings, Integer.valueOf(42));
        String s = strings.get(0); // Has compiler-generated cast
    }

    private static void unsafeAdd(List list, Object o) {
        //Le code suivant entraînera une erreur de compilation.
        // private static void unsafeAdd(List<Object> list, Object o) {
        list.add(o);
    }

}
```
- Vous pouvez utiliser le type brut si vous ne vous souciez pas du type d'élément, mais vous devriez utiliser le caractère générique **? **. Ces différences concernent également la sécurité du type.
```
package tryAny.effectiveJava;

import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class GenericsTest3 {

    public static void main(String[] args) {
        Set<?> s1 = Stream.of("2", "b", 1).collect(Collectors.toSet());
        Set s2 = Stream.of("2", "c", 1).collect(Collectors.toSet());

        // s1.add("c"); //Ce code entraînera une erreur de compilation
        s2.add("b");

        System.out.println(numElementsInCommon(s1, s2));
    }

    // Use of raw type for unknown element type - don't do this!
    static int numElementsInCommon(Set<?> s1, Set<?> s2) {
        int result = 0;
        for (Object o1 : s1)
            if (s2.contains(o1))
                result++;
        return result;
    }
}
```
- Il existe quelques exceptions à la règle selon laquelle les types bruts ne doivent pas être utilisés.
- Vous ne pouvez pas spécifier un type générique avec un paramètre de type pour un littéral de classe. Autrement dit, List.class et String []. Class sont autorisés, mais List et List <?> Ne le sont pas.
- instanceof ne peut pas être utilisé pour les types génériques qui utilisent des paramètres de type (sauf le type générique Unbounded), vérifiez donc avec le type brut à ce moment-là.
```
// Legitimate use of raw type - instanceof operator
if (o instanceof Set) {       // Raw type
    Set<?> s = (Set<?>) o;    // Wildcard type
    ...
}
```
Recommended Posts
Point 26: N'utilisez pas de types bruts

Point 41: Utiliser les interfaces de marqueurs pour définir les types

N'utilisez pas le nombre magique ...

Item 52: Utiliser la surcharge judicieusement

Point 53: Utilisez judicieusement les varargs

Point 45: Utilisez judicieusement les flux

Point 29: Favoriser les types génériques

Point 83: Utilisez judicieusement l'initialisation paresseuse

Point 66: Utiliser judicieusement les méthodes natives

N'utilisez pas `get ()` ~ Loser Facultatif

Point 59: Connaître et utiliser les bibliothèques

Élément 40: utiliser systématiquement l'annotation de remplacement

[JAVA] Point 26: N'utilisez pas de types bruts

26. Le type brut ne doit pas être utilisé