Efficacité de Java 3rd Edition Chapitre 5 Génériques

[Effective Java 3rd Edition](https://www.amazon.co.jp/Effective-Java-%E7%AC%AC3%E7%89%88-%E3%], qui est un livre indispensable pour les utilisateurs Java intermédiaires et supérieurs. 82% B8% E3% 83% A7% E3% 82% B7% E3% 83% A5% E3% 82% A2% E3% 83% BB% E3% 83% 96% E3% 83% AD% E3% 83% 83% E3% 82% AF-ebook / dp / B07RHX1K53) a une version Kindle, je vais donc le résumer.

Précédent: Classes et interfaces efficaces du chapitre 4 de Java 3rd Edition Suivant: Enum et annotations du chapitre 6 de Java 3rd Edition effective

le terme

--Type paramétré ... Liste <String>

• Paramètre de type réel ・ ・ ・ String --Type générique ・ ・ ・ Liste <E> --Paramètre temporaire ... ʻE`
• Type générique sans limite ・ ・ ・ Liste <?>
• Forme originale ... Liste --Paramètre de type de limite
• Limite rétroactive
• Type de joker de limite
• Méthode générique ・ ・ ・ statique <E> List <E> asList (E [] a) --Type de jeton ・ ・ ・ String.class

Point 26: ne pas utiliser le prototype

• N'utilisez pas le prototype, qui est un type générique sans paramètres de type. (Liste etc. sans <>) --Il est normal d'utiliser List <Object>. Vous pouvez passer List <String> à List (prototype), mais c'est sûr car vous ne pouvez pas le passer à List <Object>. --Set <Object> est un type de paramètre (sûr) qui représente un Set qui peut contenir des objets de n'importe quel type. --Set <?> Est un type générique (sûr) qui représente un Set qui peut contenir des objets d'un type inconnu.

Exemple de prototype

// NG
private final Collection stamps = ... ;
// OK
private final Collection<Stamp> stamps = ... ;

// NG
static int numElementsInCommon(Set s1, Set s2) { ... }
// OK
static int numElementsInCommon(Set<?> s1, Set<?> s2) { ... }

Élément 27 Supprimer l'avertissement non inspecté

• Tous les avertissements non cochés indiquent la possibilité d'une exception ClassCastException au moment de l'exécution. --Si vous ne pouvez pas supprimer l'avertissement non coché, supprimez l'avertissement avec l'annotation @SuppressWarnings (" non coché ") et laissez la raison dans le commentaire.

@SuppressWarnings("unchecked")Supprimer les avertissements des annotations

public <T> T[] toArray(T[] a) {
  if (a.length < size) {
    // T[]Cette conversion est correcte car elle produit un tableau du même type qui a été passé comme
    @SuppressWarnings("unchecked") T[] result = (T[]) Arrays.copyOf(elementData, size, a.getClass());
    return result;    
  }
  System.arraycopy(elements, 0,va, 0, size);
  if (a.length > size)
    a[size] = null;
  return a;
}

Élément 28 Sélectionnez une liste dans un tableau

• La séquence est défectueuse et ne correspond pas bien aux génériques. Aucun des éléments «new List []», «new List []» et «new E []» n'est autorisé.
• Les tableaux ne fournissent pas de sécurité de type au moment de la compilation, mais les génériques sont de type sûr.

Point 29 Utiliser le type générique

Génériques inutilisés

public class Stack {
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    public Stack() {
        this.elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }

    public void push(Object e) {
        ensureCapacity();
        elements[size++] = e;
    }

    public Object pop() {
        if (size == 0)
            throw new EmptyStackException();
        Object result = elements[--size];
        elements[size] = null;  //★ Supprimer les références obsolètes
        return result;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    private void ensureCapacity() {
        if (elements.length == size) {
            elements = Arrays.copyOf(elements, 2 * size + 1);
        }
    }
}

--Change ʻObject en ʻE.

Exemple de réécriture vers des génériques

public class Stack<E> {
    private E[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    @SuppressWarnings("unchecked")    //Supprimer les avertissements
    public Stack() {
        // new E[]Je ne peux pas, donc Object[]E[]Couler vers (aucun avertissement d'inspection n'apparaît)
        this.elements = (E[]) new Object[DEFAULT_INITIAL_CAPACITY];
    }

    public void push(E e) {
        ensureCapacity();
        elements[size++] = e;
    }

    public E pop() {
        if (size == 0)
            throw new EmptyStackException();
        E result = elements[--size];
        elements[size] = null;  //★ Supprimer les références obsolètes
        return result;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    private void ensureCapacity() {
        if (elements.length == size) {
            elements = Arrays.copyOf(elements, 2 * size + 1);
        }
    }
}

Point 30 Utiliser la méthode générique

• La liste des paramètres de type qui déclarent les paramètres de type pour les méthodes génériques «» se trouve entre le modificateur de méthode et le type de retour de la méthode.
• Vous pouvez être plus flexible en utilisant le type générique de limite.

Méthode générique

    public static <E> Set<E> union(Set<E> s1, Set<E> s2) {
        Set<E> result = new HashSet<>(s1);
        result.addAll(s2);
        return result;
    }

Élément 31 Utiliser des caractères génériques de limite pour améliorer la flexibilité de l'API

Exemple d'utilisation de jokers de bordure

    //Type générique pour les paramètres en tant que producteur électronique
    public void pushAll(Iterable<? extends E> src) {
        for (E e : src) {
            push(e);
        }
    }

    //Type générique pour les paramètres en tant que consommateur électronique
    public void popAll(Collection<? super E> dat) {
        while (!isEmpty()) {
            dat.add(pop());
        }
    }

• N'utilisez pas le type générique de limite comme type de retour.

public static <E> Set<E> union(Set<? extends E> e1, Set<? extends E> e2)

Point 32: Combinez soigneusement les génériques et les arguments de longueur variable

• Les méthodes d'argument de longueur variable et les génériques ont été ajoutés en même temps dans Java 5, mais ils ne fonctionnent pas ensemble.
• La pollution de tas se produit lorsqu'une variable d'un type paramétré fait référence à un objet qui n'est pas de ce type.
• Il n'est pas sûr de stocker des valeurs dans des paramètres génériques de tableau de longueur variable.
• Les paramètres de longueur variable génériques ne sont pas de type sûr mais autorisés.
• Lors de l'écriture d'une méthode avec un paramètre de longueur variable générique, commencez par sécuriser le type de méthode. Annotez «@ SafeVarags» pour en faciliter l'utilisation.

Point 33 Envisagez un contenant hétérogène de type sûr

• Un conteneur qui stocke les clés en tant que classe et les valeurs en tant qu'instance dans la carte.

Modèle de conteneur hétérogène de type sécurisé

public class Favorites {
    private Map<Class<?>, Object> favorites = new HashMap<>();

    public <T> void putFavorite(Class<T> type, T instance) {
        favorites.put(Objects.requireNonNull(type), instance);
    }

    public <T> T getFavorite(Class<T> type) {
        return type.cast(favorites.get(type));
    }
}

//Exemple d'appel
Favorites f = new Favorites();
f.putFavorite(String.class, "Java");
f.putFavorite(Integer.class, 0xcafebabe);
f.putFavorite(Class.class, Favorites.class);
String favoriteString = f.getFavorite(String.class);
int favoriteInteger = f.getFavorite(Integer.class);
Class<?> favoriteClass = f.getFavorite(Class.class);