Java 泛型总结

1. 泛型类

class Gen<T> {
    private T t;
    
    public  T get(){
        return t;
    }
    
    public void set(T argt){
        t = argt;
    }
}

       “<>”内的T为类型参数，只能是类名，不能是基本类型（如int , double），泛型类（以及后面讲到的泛型方法）可以有多个类型参数。

class Pair<K,V>{
    private K k;
    private V v;
    ……
}

       类型参数可以看做这个泛型类操作的数据类型

         泛类型的使用

Gen<String> gs = new Gen<String>();
gs.set("abc");
String str = gs.get();

2. 泛型方法

class GenFun{
    public <T> T Mid(T[] a){
        return a[a.length/2];
    }
}

        这是一个普通类，但是具有一个泛型方法，返回T类对象数组的中间位置的元素引用，泛型方法需要在返回值前用“<>”说明类型参数。

       (1)如果一个泛型类中有泛型方法，泛型方法的类型参数可以与泛型类的类型参数不同。

       (2)若在泛型类中的静态方法要访问泛型参数，必须使它变成泛型方法。

3.类型参数的限定

限定上限关键字 extends

class GenFun{
    public <T extends Comparable<T>> T Max(T[] a){
        T max = a[0];
        for(T t: a){
            if(t.compareTo(max) > 0){
                max = t;
            }
        }
        return max;
    }
}

         <T extends A> 这里的extends表示类型参数T必须就是A类或者A的子类，或者表示T需要实现A这个接口。上面的例子就表示T必须实现Comparable接口（注意Comparable接口本身又是个泛型接口）。

现在我们来举一个例子，来说明上限限定符的使用规则，假设E继承 D, D继承C, C继承B, B继承A

class A{};
class B extends A{};
class C extends B{};
class D extends C{};
class E extends D{};
class F{};

class Gen<T extends C> {
    private T t;
    
    public  T get(){
        return t;
    }
    
    public void set(T argt){
        t = argt;
    }
}

public class GenTest {
    public static void main(String[] args) {
        //----------------------
        Gen<F> gf = new Gen<F>();//编译出错 F不是C的子类
        Gen<B> ga = new Gen<B>();//编译出错 B是C的父类
        
        //----------------------
        Gen<C> gc = new Gen<C>();//编译成功
        gc.set(new B());//编译出错 B不是C的子类

        Gen<D> gd = new Gen<D>();//编译成功
        gd.set(new D());//编译成功
        D d0 = gd.get();//编译成功
        
        gd.set(new E());//编译成功，把E的对象当做D对象看待
        D d1 = gd.get();//编译成功，注意返回的类型为D
    }
}

有多个限定条件可以用“&”连接，多个限定条件中只能有一个类，其它的都为接口

限定下限关键字 super

class Gen<T super D> {//编译错误
    ……
}

        限定条件可用来单独限定方法（即泛型方法），也可以用来限定整个类。含有通配符的限定条件用于创建泛型类的引用。

4. 擦除

都是Object

         实际上java语言中并没有泛类型对象，所有对象都是普通对象，也就说泛型仅仅存在于编译阶段。这一点我们可以从Gen<T>的字节码中得到印证。查看字节码我使用的是Bytecode visualizer插件，可以从http://marketplace.eclipse.org/下载到。

class Gen<T> {
    /* compiled from GenTest.java *
    private T t;

    Gen() {
        /* L18 */
        0 aload_0;                /* this */
        1 invokespecial 12;       /* java.lang.Object() */
        4 return;
    }

    public java.lang.Object get() {
        /* L22 */
        0 aload_0;                /* this */
        1 getfield 23;            /* .t */
        4 areturn;
    }

    public void set(java.lang.Object arg0) {
        /* L26 */
        0 aload_0;                /* this */
        1 aload_1;                /* argt */
        2 putfield 23;            /* .t */
        /* L27 */
        5 return;
    }
}

        注意get方法的返回值类型和set方法的参数类型都是Object。可以看出泛型类中，将泛型对象都用Object对象代替。由于get方法应该根据具体的类型参数返回一个对应类型的对象，那么这一点又是如何实现的。不妨先来观察下面的代码。

public class GenTest {
        public static void main(String[] args) {
        Gen<D> gd = new Gen<D>();
        gd.set(new D());
        D d0 = gd.get();
    }
}

         代码的意思很简单就是实例化一个Gen<D>的对象，并调用它的get和set方法。我们再来看看上述代码对应的字节码（省略了不相干的部分）。

public static void main(java.lang.String[] args) {
        /* L69 */
        0 new 16;
        3 dup;
        4 invokespecial 18;       /* javaleanning.Gen() */
        7 astore_1;               /* gd */
        /* L71 */
        8 aload_1;                /* gd */
        9 new 19;
        12 dup;
        13 invokespecial 21;      /* javaleanning.D() */
        16 invokevirtual 22;      /* void set(java.lang.Object d0) */
        /* L72 */
        19 aload_1;               /* gd */
        20 invokevirtual 26;      /* java.lang.Object get() */
        23 checkcast 19;          /* javaleanning.D */
        26 astore_2;              /* d0 */
        /* L106 */
        27 return;
}

         第20行是调用get方法，注意23行，它是进行强制类型转换，26行是将结果传递给引用d0。也就是说泛型的实现原理就是在需要返回某个泛型对象之前，进行强制类型转换。在使用泛型类中的方法或泛型方法时，会用实际的类名去替换T，这样一来编译器就知道了强制转换的类型。还有一点要说明，强制转换的代码是编译器在调用get方法时插入的，get方法中并没有进行强制类型转换（它也不知道该转换成什么类型的对象），这样可以使得泛型类和泛型方法的编译不依赖于T的具体类型。

class Gen<T> {
    private T t;
    
    public  T get(){
        return t;
    }
    
    public  void set(T argt){
        t = argt;
    }
    
    public void set(Object argt){ //编译出错
        t = argt;
    }
}

        上述泛型类中添加一个public Object get() ，则会出现编译错误，原因是在编译时，set(T argt)会将泛类型擦除，变成set(Object argt)，这样一个类中就存在两个完全相同的方法。

静态数据公用

     因为擦除效应，类型参数不同的泛型类使用的是同一代码和静态数据。。我们在G<T>中添加一个静态变量n

class Gen<T> {
    private T t;
    
    public static int n = 0;
    
    public  T get(){
        return t;
    }
    
    public  void set(T argt){
        t = argt;
    }
}

         现在我们做一个测试。

Gen<D> gd = new Gen<D>();
gd.n = 100;
Gen<E> ge = new Gen<E>();
System.out.println(ge.n);

         最后的输出结果是100。

5. 覆盖

            现在有一个SubGen类继承了Gen<A>，并想覆盖Gen<A>的set方法。

class SubGen extends Gen<A>{
    public void set(Object o){ //编译出错
        System.out.println("from SubGen set ");
    }
}

        虽然Gen<A>被擦除后的set方法的原型就是set(Object o)，但是想覆盖父类G<A>的set方法，上述写法会出现编译错误。因为编译器以为它成功的欺骗了我们，让我们以为存在泛类型，我们这么写就是告诉它我们识破了骗局，编译器必然不高兴了，编译就不能成功（真正的原因后面会介绍）。所以我们必须假装不知道有擦除这回事，按照泛型的方式来处理。编译器以为我们会认为Gen<A>的set方法的原型是set(A a)，所以我们必须这么写代码才能实现子类对（泛型）父类中方法的覆盖。

class SubGen extends Gen<A>{
    public void set(A a){
        System.out.println("from SubGen set");
    }
}

      但是现在还有个疑问，明明泛型中的类型参数编译时都替换成了Object，那么子类中的set(A a)就不能覆盖父类中的set(Object argt)方法了（因为这两个方法的参数不同），但是我们运行下面的代码却能得到正确的结果（输出 from SubGen set）。

Gen<A> ga = new SubGen();
ga.set(null);

        要解释这个原因，我们可以查看SubGen的字节码。

    public void set(javaleanning.A arg0) {
        /* L34 */
        0 getstatic 16;           /* java.lang.System.out */
        3 ldc 22;                 /* "from SubGen" */
        5 invokevirtual 24;       /* void println(java.lang.String arg0) */
        /* L35 */
        8 return;
    }

    /* bridge method generated by the compiler */
    public volatile void set(java.lang.Object arg0) {
        /* L1 */
        0 aload_0;
        1 aload_1;
        2 checkcast 33;           /* javaleanning.A */
        5 invokevirtual 35;       /* void set(javaleanning.A arg0) */
        8 return;
    }

         可以看到SubGen中有两个set方法，public void set(javaleanning.A arg0)是我们自己编写了，而另一个public volatile void set(java.lang.Object arg0) 是编译器自动帮我们添加的（注意代码的注释bridge method generated by the compiler）。添加的这个方法正好和父类中擦除掉泛型的set方法同名且同参数public volatile void set(java.lang.Object arg0)，这就实现了子类对父类方法的覆盖，而set(java.lang.Object arg0)内部就是仅仅调用了我们写的set(javaleanning.A arg0)方法。现在我们回头看看前面我们编译出错的代码，原因就显而易见了。因为编译器帮我们编写了一个set(java.lang.Object arg0)方法，如果我们自己也实现一个set(Object o)，那么两个（另一个由编译器自动生成）一样的方法必然会产生冲突，所以会编译失败。

         现在SubGen中添加set方法想要覆盖掉父类Gen<A>中的set方法。那么我们可以这么写（代码没有什么具体意义，添加输出语句，只是为了区别子类中的方法和父类中的方法）。

class SubGen extends Gen<A>{
    public void set(A a){
        System.out.println("from SubGen set");
    }
    
    public A get(){
        System.out.println("from SubGen get");
        return new A();
    }
}

         我们使用下面的代码测试

Gen<A> ga = new SubGen();
ga.set(null);
ga.get();

            可以得到正确的结果

             from SubGen set

             from SubGen get

             我们查看字节码可以发现一个有趣的问题

   public javaleanning.A get() {
        /* L38 */
        0 getstatic 16;           /* java.lang.System.out */
        3 ldc 22;                 /* "from SubGen" */
        5 invokevirtual 24;       /* void println(java.lang.String arg0) */
        /* L39 */
        8 new 34;
        11 dup;
        12 invokespecial 36;      /* javaleanning.A() */
        15 areturn;
    }

    /* bridge method generated by the compiler */
    public volatile java.lang.Object get() {
        /* L1 */
        0 aload_0;
        1 invokevirtual 38;       /* javaleanning.A get() */
        4 areturn;
    }

         SubGen 中有两个get方法,它们仅仅返回值不同。一般情况下，程序员这样写代码必然会导致编译错误，但是由于是编译器自己添加的一个方法（java.lang.Object get()），所以的确能够编译成功，并且编译器能够通过返回值的不同来区分这两个方法。

6.泛型中的继承

可以使用子类实例

           我们仍然假设E继承 D, D继承C, C继承B, B继承A。那么Gen<C> 中的方法可以处理 类C的实例，类D的实例，类E的实例，但不能处理类B的实例和类A的实例。

     Gen<C> gc = new Gen<C>();
        gc.set(new C());
        C c = gc.get();
        
        gc.set(new D());
        c = gc.get();
        D d = (D) gc.get();
        
        gc.set(new E());
        c = gc.get();
        d = (D) gc.get();
        E e = (E) gc.get();
        
        gc.set(new A()); //编译错误
         gc.set(new B()); //编译错误

继承中的限制

           虽然，E继承 D, D继承C, C继承B, B继承A，但是Gen<A>，Gen<B>，Gen<C> ，Gen<D>，     Gen<E> 之间没有任何继承继承关系。因为泛类型的本质就是增强强制转换的安全性，将本来由程序员进行的强制转换工作交给编译器来完成。假设由于B继承了A使得Gen<B>继承Gen<A>，这就可能导致运行时的错误。

       Gen<B> gb = new Gen<B>();
       Gen<A> ga = gb; //编译错误
        ga.set(new A());
       B b = gb.get();

         一般来说在Gen<B>放入一个B的实例，但是取出一个A的实例一般没有什么问题，但是如果允许Gen<A> 和 Gen<B> 存在继承关系，按照上如代码，我们就可以让Gen<A>的实例ga和Gen<B>的实例gb指向同一Gen<B>实例，用ga存入一个A类的实例，利用gb的get方法取出一个B类的实例，这就显然会引起运行时的错误。

            泛型中的继承的继承情况有很多种，可以继承一个具体的泛型类（像上述的“覆盖”章节中    class SubGen extends Gen<A>），还一个继承一个纯粹的泛型类

class SonGen<U, T> extends Gen<T>{
    private U u;//只是定义一个变量而已
     public  void set(T argt){// 覆盖父类中的方法
        System.out.println("I am SonGen");
    }
}

         SonGen<U, T> 继承了 Gen<T> ，并添加了一个类型类型参数。当然还可以继承具有泛型方法的类，这里就不举例了。

7.通配符及类型参数的限定

             泛型中对继承的限制是为了解决类型转换的安全性问题，但是却违背了java中多态的原则。为了同时解决泛型中的安全性和多态原则，java引用通配符。我们继续使用上面的Gen<T>和类A、B、C、D、E作为例子。通配符“ ？”表示任意类型，它的使用有三种形式。

通配符与上限限定符

              Gen<? extends B >表示Gen的类型参数是类B或者任何类B的子类。Gen<? extends B >中的两个方法（set 和 get）实际上被通配符和限定符后变成了如下的形式

              set( ? extends B )

              ? extends B get()

              我们现在来看一下它的使用

       Gen<? extends B> gec = new Gen<D>(); //编译成功
        gec.set(new C()); //编译错误
        gec.set(new D()); //编译错误
        gec.set(new E()); //编译错误
        B b = gec.get();  //编译成功

         现在对上述代码进行解释。第一行能编译成功，是因为满足 D 是 B 的子类。

         最后一行没有错误，因为编译器只知道gec是对Gen<B>的子类对象的引用，而具体是哪个子类它并不清楚，但是B子类的对象一定可以转换成B类型的对象。

          而所有调用的set方法的语句都会出现编译错误，因为编译器只知道gec是对Gen<B>的子类对象的引用，而具体是哪个子类它并不清楚（上述代码中指向了Gen<D>的对象），所以编译器gec把它所指的对象仅当做当做Gen<B>来使用，所以编译器拒绝一切 ? extends B 作为参数，这样做是保障泛型的安全性。比如有个类F，它也继承了B类，而F类和D类不存在继承关系。

       Gen<D> gd = new Gen<D>();
      Gen<? extends B> gec = gd;
      gec.set(new F());//如果编译成功
       D d = gd.get();

         若gec.set(new F())编译通过，那么D d = gd.get()必然出现运行错误，因为返回的实际上是个F类型的对象,却被转换成了D类型。

通配符与下限限定符

              Gen<? super D>表示Gen的类型参数是类D或者任何类D的父类。Gen<? super D >中的两个方法（set 和 get）实际上被通配符和限定符后变成了如下的形式

              set( ? super D )

              ? super D get()

             我们现在来看一下它的使用

       Gen<? super D> supd = new Gen<B>();
        supd.set(new A()); //编译错误
        A a = supd.get();  //编译错误

        
        supd.set(new C()); //编译错误
        C c = supd.get();  //编译错误
        
        supd.set(new D());
       D d = supd.get();  //编译错误
        d = (D)supd.get();
       supd.set(new E());
       Object o = supd.get();

         在对上述代码进行解释。第一行能编译成功，是因为满足 B 是 D 的父类。

         如果不加强制转换，所有调用的get方法的语句都会出现编译错误，原因其实和上面类似，编译器只知道supD是对Gen<D>的父类对象的引用，而具体是哪个父类它并不清楚，由于get的返回值类型是? super D编译器就没有办法确定应该转换成D类具体的哪种类型。

         supd.set(new D())和supd.set(new E())能够编译成功的原因是，虽然编译器只知道supD是对Gen<D>的父类对象的引用，而具体是哪个父类它并不清楚，但是D类的实例和E类的实例一定能够当做D的父类型的实例来对待。

         A是D的父类，但是以A类的对象作为参数的get 和 set 方法都会编译失败，这似乎和限定符表示的意思不相符。但是考虑以下的代码：

         Gen<B> gb = new Gen<B>();
        Gen<? super D> supC = gb;
        supC.set(new A());
        B b = gb.get();

         如果upC.set(new A())能够编译成功，那么B b = gb.get()一定会出现异常，因为出现了向上转型（由父类A转向了子类B）。

无限定通配符

          Gen<?> 等价于Gen<? extends Object> 表示Gen的类型参数是Object或者Object的子类

通配符小节

       （1） extends 可用于的返回类型限定，不能用于参数类型限定。

       （2） super 可用于参数类型限定，不能用于返回类型限定。

       （3） 通配符一般用于创建泛型类的引用

         假设X表示一个具体的类，注意区别 ? extends X 和Gen<? extends X> 。Gen<? super X>和   Gen<? extends X>两者可以作为参数类型也可以作为返回值类型，可参见 ArrayList代码。

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    int srcSize = src.size();
    if (srcSize > dest.size())
        throw new IndexOutOfBoundsException("Source does not fit in dest");
    if (srcSize < COPY_THRESHOLD ||
        (src instanceof RandomAccess && dest instanceof RandomAccess)) {
        for (int i=0; i<srcSize; i++)
            dest.set(i, src.get(i));
    } else {
        ListIterator<? super T> di=dest.listIterator();
        ListIterator<? extends T> si=src.listIterator();
        for (int i=0; i<srcSize; i++) {
            di.next();
            di.set(si.next());
        }
    }
}

8. 泛型的局限性

        虽然java没有真正的泛型，但是编译器在编译阶段会做一些语法上的限制

      （1）判断某个对象是否是泛型类的实例的正确方法

        Gen<B> gb = new Gen<B>();
        if(gb instanceof Gen<?>){
            System.out.println("only correct way");
        }

       （2） class实际上是个泛型类 原型为class<T>。A.class 是 Class<A>的唯一一个实例，String.class是Class<Stiring>的唯一一个实例

       （3）不能实例化泛型变量，即不能使用
                    new T()
                    T.class
         如果要实例化一个泛型变量，可以在泛型类中添加一个静态方法，并传入class<T>类型的参数

public static <T> T makeTobj(Class<T> cl){
     try {
            return cl.newInstance();
     } catch (InstantiationException | IllegalAccessException e) {
     }
     return null;
}

      （4） 没有泛型数组，如果需要在泛型类中创建一个泛型数组，可以用Object类型的数组代替。我们可以参照ArrayList的源代码。

public class ArrayList<E> extends AbstractList<E> 

  implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
    //省略无关代码
    transient Object[] elementData; 

   // non-private to simplify nested class access

    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }
}

        并可以直接返回数组中的某个对象，因为编译器会在代用该代码时自动添加强制类型转换。

        如果需要返回泛型的数组，我们可以new Object[] 或者利用Array.newInstance类中的方法创建特定类型的数组，然后进行强制类型转换（T[]）。参见ArrayList代码。

public static <T,U> T[] copyOf(U[] original, int newLength,

                                  Class<? extends T[]> newType){
    @SuppressWarnings("unchecked")
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), 

                                  newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

      虽然不能创建泛型数组，但是可以创建泛型数组的引用 Gen<T>[] genArr;

    （5） 没有泛类型的静态数据成员