由于长时间没有使用泛型库，我正在创建一个大量使用泛型的库。我忘记了一些东西并陷入了一些困境，所以现在我将它们作为备忘录总结起来。

“用語” 可以被漢語化為 “术语” 。

鉴于泛型存在类似的术语，很容易引起混淆，因此首先要确切地理解这些术语。
以下内容摘自《Effective Java》的第23条。

变性

在泛型类型X中，当类型A是类型B的子类型时，如果X是X的子类型，则X在类型参数T上是协变的（covariant）。相反地，如果X是X的子类型，则X被称为反变的（contravariant）。如果两者都不成立，则称为不变的（invariant）。泛型类型具有这些变异之一。以下是示例。

Java的泛型是不变的。

在Java中，泛型是不变的。因此，虽然Integer是Number的子类型，但List不是List的子类型。

在以下的示例代码中展示了一个例子。

    public void hoge() {
        List<Integer> intList = new ArrayList<>();
        List<Number> numList = new ArrayList<>();
        List<Number> anotherNumList = new ArrayList<>();

        numList = anotherNumList; //OK
        numList = intList; //コンパイルエラー       
    }

数组是协变的。

相比之下，Java的数组具有共变性。因此，可以编写出以下这种危险的代码。

    public static void foo() {
        Object[] objects;
        Integer[] integers = new Integer[]{1,2,3};
        objects = integers;
        objects[0] = "error"; //実行時例外 ArrayStoreExceptioin
    }

在编译时，类型信息被擦除

参数化类型和类型参数的类型信息将被编译器消除。这被称为类型擦除。

例如，考虑一个具有以下类型变量T的泛型类型。
Container是一个容器类，它仅保持Number类型的值，如Integer或BigDecimal。

class Container<T extends Number> {
    private T value;    
    public Container(T value) {
        this.value = value;
    }   
    public T get() {
        return value;
    }
}

编译器会从上述类中清除类型信息，并生成与下面的类等效的类。

class Container {
    private Number value;
    public Container(Number value) {
        this.value = value;
    }
    public Number get() {
        return value;
    }
}

尽管我们称之为类型信息，但实际上并不会被真正删除，类型参数会被替换为其上限边界的类型（在上述例子中为Number）。
因此，由于类型信息被编译器删除，无法在运行时获取类型信息。

无法创建 new T()

由于类型参数会被擦除，所以无法创建类型为T的实例。

class Illegal<T> {
    public T create() {
        return new T();
    }
}

如果非做不可的话，只有以下的方式可选。

class Legal<T> {
    public T create(Class<T> clazz) throws Exception {
        return clazz.newInstance();
    }
}

无法创建新的T[]。

对于泛型类型，可以根据以下方式生成一个以T为类型的实例。

class Sample<T> {
    public List<T> createList(int size) {
        //TのArrayListを生成できる
        return new ArrayList<T>(size);
    }
}

一方，无法创建一个以类型参数T作为元素的数组。

class Sample<T> {   
    public T[] createArray(int size) {
        return new T[size];
    }   
}

就像之前解释过的那样，类型参数T的类型信息会在运行时被擦除。在泛型类型的情况下，会生成不包含类型信息的原型，因此在运行时不需要类型信息。然而，在生成数组时需要运行时的类型信息（确切地说是生成数组的字节码需要类型信息），所以无法生成以类型参数T为元素的数组。

List<?> 表示具有任意元素类型的列表。

List<?> 表示具有某种类型元素的列表。这种类型被称为非边界通配符类型。List<?>的变量可以赋值为任何列表。因此，可以编写以下代码。

    public void wildcardHasAnyType() {
        List<String> stringList = new ArrayList<>();
        List<Integer> integerList = new ArrayList<>();

        boolean b1 = contains(stringList, "a"); //List<String>
        boolean b2 = contains(integerList, 3); //List<Integer>
    }

    public boolean contains(List<?> list, Object o) {
        return list.contains(o);
    }

这与由于协变属性，无法将List赋值给List