关于泛型

• 静态方法无法访问泛型的类型参数。（C++可以）
• Java泛型使用擦除实现，如运行时，List<A>，List<B>的类型参数会被擦除，都为List类型。
• 由于Java泛型使用擦除实现，在泛型代码内部，无法获取任何有关泛型参数类型的信息。
• 虽然无法再泛型中获取任何有关泛型参数类型的信息，但是使用了泛型能让编译器在编译期保证所有相同泛型参数类型具有一致性。
• 泛型类没有明确写上类型实参的时候，默认为Object。

泛型边界

• <T extends A & B>：所有继承A和B的类。
• <T super A>：不存在这种用法。

通配符

class A {}
class B extends A {}
class C extends B {}
class D<T> {
    D() { }

    void fun1(T t) { }

    T fun2() { return null; }
}

public class E {
    public static void main(String[] args) {
        A a = null;
        B b = null;
        C c = null;

        // super
        // <? super B>用于泛型类型参数时
        D<? super B> l1 = new D<A>();
        D<? super B> l2 = new D<B>();
        D<? super B> l3 = new D<C>();  // 错误

        // <? super B>用于方法参数时
        l1.fun1(new A());  // 错误
        l1.fun1(new B());
        l1.fun1(new C());

        // <? super B>用于返回值
        a = l1.fun2();  // 错误
        b = l1.fun2();  // 错误
        c = l1.fun2();  // 错误

        // extends
        // <? extends B>用于泛型类型参数
        D<? extends B> l4 = new D<A>();  // 错误
        D<? extends B> l5 = new D<B>();
        D<? extends B> l6 = new D<C>();

        // <? extends B>用于方法参数
        l5.fun1(new A());  // 错误
        l5.fun1(new B());  // 错误
        l5.fun1(new C());  // 错误

        // <? extends B>用于返回值
        a = l5.fun2();
        b = l5.fun2();
        c = l5.fun2();  // 错误，需要强制类型转换
    }
}

• extends通配符：可以改成接受Object类型解决extends通配符用于方法参数时无法接受任何实参的问题。
• 无界通配符：用来提示编译器不要使用原生类型，而使用泛型。（因为Java泛型鸡肋，从原生类型发展而来，所以大部分时候没什么卵用。List<?>看起来跟List没什么区别。）
• 通配符要点：通配符代表着一个 类型范围 ，而不是具体某个类型，也不是自动类型推断，不会推断为一个具体类型。
• 任何基本类型不能作为泛型类型参数，可以使用包装器取而代之。

自限定

循环泛型

• 循环泛型：因为Java的泛型中的类型参数仅仅影响的只是方法参数和方法返回值，所以不需要定义了B才能用B作为类型参数。

interface A<T> {}
class B implements A<B> {}

自限定泛型类

// 自限定泛型
class SelfBounded<T extends SelfBounded<T>> {}
// 强制用循环泛型的方式使用自限定泛型
class A extends SelfBounded<A> {}
class D {}
// 禁止如下使用自限定泛型
class E extends SelfBounded<D> {}  // 错误
// 神奇
class F extends SelfBounded {}
public class SelfBounding {
    public static void main(String[] args) { }
}

自限定泛型方法

• 自限定泛型方法：强制泛型参数T为循环泛型类。

class SelfBounded<T extends SelfBounded<T>> {}
class A extends SelfBounded<A> {}

public class SelfBoundingMethods {
    private static <T extends SelfBounded<T>> T fun(T arg) {
        return arg;
    }
    public static void main(String[] args) {
        A a = fun(new A());
    }
}

注意事项

• 自限定的价值在于产生 参数类型协变 ：不用改变基类代码就可以使基类方法参数类型会随子类而变化。（ C++只能返回类型协变？ ）
• 自限定虽然也能使 返回类型协变 ，但是意义不大，SE5开始Java就能不用通过自限定的方式实现返回类型协变（不需要泛型，单继承就能实现）。