[JAVA] Point 29: Favoriser les types génériques

29. Utiliser le type générique

• Considérez l'implémentation de pile simple décrite dans Item7.

package tryAny.effectiveJava;

import java.util.Arrays;
import java.util.EmptyStackException;

//Object-based collection - a prime candidate for generics
public class Stack1 {
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    public Stack1() {
        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; // Eliminate obsolete reference
        return result;
    }

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

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

}

• Pour rendre une classe générique, ajoutez d'abord un paramètre de type à la classe. La pile ci-dessus nécessite un paramètre de type unique, qui est un élément de la pile, il est donc généralement nommé E (Item68).
• Remplacez ensuite tous les types d'objets par les paramètres de type appropriés afin qu'ils puissent être compilés.
• L'une des solutions de contournement lorsqu'un tableau de type non réifiable est créé est de créer un nouveau tableau avec Object et de le convertir, mais ce n'est généralement pas de type sécurisé. Dans ce cas, le problème est la source dans le constructeur, mais le champ des éléments est privé et aucune valeur n'est entrée à partir d'autre chose que la méthode push, donc la réalité est garantie être E. Par conséquent, l'avertissement doit être effacé en donnant @ SuppressWarning ("unchecked") `` dans la plage minimale et avec un commentaire.

package tryAny.effectiveJava;

import java.util.Arrays;
import java.util.EmptyStackException;

//Initial attempt to generify Stack - won't compile!
public class Stack2<E> {
    private E[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    // The elements array will contain only E instances from push(E).
    // This is sufficient to ensure type safety, but the runtime
    // type of the array won't be E[]; it will always be Object[]!
    @SuppressWarnings("unchecked")
    public Stack2() {
        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; // Eliminate obsolete reference
        return result;
    }

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

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

}

• Une autre façon de gérer la création d'un tableau de type non réifiable est de déclarer le tableau en tant qu'objet. Même dans ce cas, une erreur se produira dans la méthode pop telle qu'elle est, donc lancez-la. Si vous le lancez, vous obtiendrez un avertissement, mais pour la même raison que ci-dessus, il est évident que vous pouvez lancer à nouveau E, alors ajoutez `@ SuppressWarning (" unchecked ")` dans la plage minimale (Item27).

package tryAny.effectiveJava;

import java.util.Arrays;
import java.util.EmptyStackException;

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

    public Stack3() {
        elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }

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

    public E pop() {
        if (size == 0)
            throw new EmptyStackException();
        // push requires elements to be of type E, so cast is correct
        @SuppressWarnings("unchecked")
        E result = (E) elements[--size];
        elements[size] = null; // Eliminate obsolete reference
        return result;
    }

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

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

}

• En ce qui concerne les deux méthodes ci-dessus, la première est plus facile à lire et la conversion ne doit être effectuée qu'une seule fois lorsque l'instance est créée, la première est donc généralement utilisée plus souvent. Cependant, la pollution du tas (Item32), c'est-à-dire le type du tableau au moment de l'exécution et le type au moment de la compilation sont différents, de sorte que certains programmeurs sont frustrés de choisir ce dernier.
• L'exemple ci-dessus contredit le conseil de Item28 d'utiliser list over array, mais Java ne prend pas en charge la liste par nature et vous devez utiliser array quelque part dans le type générique. Par exemple, ArrayList utilise des tableaux. De plus, HashMap etc. utilise des tableaux pour les performances.
• Fondamentalement, tout peut être spécifié pour le paramètre type dans l'exemple ci-dessus, mais si un type primitif tel que Stack ou Stack est spécifié, une erreur de compilation se produira. Si vous souhaitez utiliser un type primitif, spécifiez le type encadré dans le paramètre type (Item61).
• Certains types génériques imposent des restrictions sur les paramètres de type. Par exemple, la classe DelayQueue utilise des paramètres limités comme suit:

class DelayQueue<E extends Delayed> implements BlockingQueue<E>