java泛型，怎么这么难

泛型，就是参数化类型。好吧，这是我抄的定义，自己都觉得难以理解。还是举个简单例子吧。

public class SimpleJava {
    T t;
    public static void main(String[] args) {
        SimpleJava sj = new SimpleJava<>();
        sj.t = Integer.valueOf(1);
    }
}

看见没，就是类型不确定，使用参数进行表示，那这么写有什么好处呢？我们继续讨论。

为什么使用泛型？

我们看段代码，来感受下泛型的便利。

public class SimpleJava {
    private T t;

    public SimpleJava(T t) {
        this.t = t;
    }
    public T getT() {
        return t;
    }
    public static void main(String[] args) {
        SimpleJava sj = new SimpleJava(1);
        Integer result = sj.getT();

        SimpleJava sj1 = new SimpleJava("a");
        String result1 = sj1.getT();
    }
}

看上面代码，我们发现T和直接用object类型没什么两样。仔细看，发现没，sj.getT()和sj1.getT()的返回值能够自动进行正确的类型转换。我们知道，所有的类型转换都是在运行期进行，如果出错，会抛出类型转换异常：ClassCastException，而使用泛型则不会，我们看下编译后的汇编：

public static void main(java.lang.String[]);
    Code:
       0: new           #1                  // class com/esy/rice/tool/simple/SimpleJava
       3: dup           
       4: iconst_1      
       5: invokestatic  #29                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
       8: invokespecial #35                 // Method "":(Ljava/lang/Object;)V
      11: astore_1      
      12: aload_1       
      13: invokevirtual #37                 // Method getT:()Ljava/lang/Object; //返回的还是Object
      16: checkcast     #30                 // class java/lang/Integer //编译器自动插入类型转换指令
      19: astore_2      
      20: new           #1                  // class com/esy/rice/tool/simple/SimpleJava
      23: dup           
      24: ldc           #39                 // String a
      26: invokespecial #35                 // Method "":(Ljava/lang/Object;)V
      29: astore_3      
      30: aload_3       
      31: invokevirtual #37                 // Method getT:()Ljava/lang/Object;//返回的还是Object
      34: checkcast     #41                 // class java/lang/String //编译器自动插入类型转换指令
      37: astore        4
      39: return        
}
}

我们进行有泛型和没泛型编码的对比：

public class SimpleJava {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(1);
        list.add("2");

        List list2 = new ArrayList();
        list2.add(1);
        list2.add("2"); //编译期会直接报错
    }
}

从上面可以看出，这是编译器对代码的优化，帮助进行类型转换，人会犯错，而编译器则不允许（不然谁用）。编译器既然能够进行正确的类型转换，那么必然的知道正确的类型，机制就是类型声明时<>中的具体类型信息。
由此看来，就编译期类型检查这一项的便利，就有足够的理由让我们使用泛型了。

泛型的不变性

不变性？说出来有些唬人，什么叫不变呢？来个比较，可能更明了，看代码：

    public static void main(String[] args) {
        List