Java泛型

 参考文章：http://www.infoq.com/cn/articles/cf-java-generics

1、Java泛型是Java5以后才出现的特性，主要是为了代码重用的同时在编译器来避免类型转换问题。泛型的存在的意义在于类型替换，和禁止一些可能出现类型转换问题的编码，在编译期就报错

2、Java源代码首先通过编译得到class字节码文件，然后在jvm中运行。java class文件中是不存在类型信息的，也就是说开始定义的泛型都会在编译后消失。这就是类型檫除，Java中的泛型基本上都是在编译器这个层面上实现的。例如

List<String>和List<Integer>等类型在编译之后都变成List。因此有以下几种特性：

（1）只存在List.class,而不存在List<String>.class,List<Integer>.class

（2）静态变量是由类的所有实例共享的，因此不能定义泛型的静态变量

public class MyClass<T>{
   private static T s;//编译错误
}

（3）异常类是在运行时抛出，通过catch捕获，但是运行时类型信息被抹去，所以对于MyException<String>和MyException<Integer>对于catch来说无法分辨

3、编译期间，对于泛型T来说，先用object进行替换，如果利用extends定义了上界，那么就利用上界类进行替换。

4、通配符？和上下界extends、super

（1）通配符？表示类型未知，因此可以传入任意类型。从语法层面上规定了通配符指定的对象不能实例化，因为类型未知。例如new ArrayList<?>()是错误的。下面例子中的alist.add(1)也是禁止的，因为List类型未知。试图对一个带通配符的泛型类进行操作都会出现编译错误。它和List<Object>的区别在于，即使是Object也是类型已知可以进行操作和实例化，所以下面代码中blist.add(1)是不会报错的。如果参数是List<Object>，传入List<String>,虽然理解上是可以的，但是编译器为了避免出现blist.add(1)这种在String列表中加入Integer的行为导致的ClassCastException，所以禁止这样做。

（2）定义泛型后，就给原来的继承体系增加了一个维度。例如Collection<? extends Number> ,List<Integer>,Set<Integer>和List<Double>,Set<Double>都是其子类，都可以作为匹配参数传入

下面的代码

public class GenericTest<T extends Number> {
    public void get(List<?> alist) {
        alist.get(0);
  alist.add(1);//？通配符，表示类型未定，编译器禁止add
    }

    public void getO(List<Object> blist) {
  blist.add(1);//在该函数内部，list加入一个整型是没错的
    }

    public void test() {
        get(new ArrayList<String>());//正确
        get(new ArrayList<Integer>());//正确
        getO(new ArrayList<String>());//编译错误，因为可能会出现潜在的类型转换问题
    }
}

（3）？extends XX限定了?匹配的上界，只有XX及其子类可以通过匹配。其主要应用场景是可以get得到XX的引用，来调用XX指定的方法，但是不能直接add，因为传入的参数确定的类型是其子类，add父类是不行的

（4）？super XX限定了?匹配的下界，只有XX及其父类可以通过匹配。其主要应用可以add加入XX的实例，因为XX是下界，传入的只能是XX及其父类，向上转型是可以的。但是不能get到XX的引用

public class GenericTest<T extends Number> {

    public void get1(List<? extends B> alist) {

    }
    public void get2(List<? super B> alist) {

    }
    public void test() {
        get1(new ArrayList<A>());//编译错误，B或者其子类
        get1(new ArrayList<B>());
        get1(new ArrayList<C>());
        get2(new ArrayList<A>());
        get2(new ArrayList<B>());
        get2(new ArrayList<C>());//编译错误，B或者其父类
    }

 public void upperBound(List<? extends Date> list, Date date)
 {
      Date now = list.get(0);
      System.out.println("now==>" + now);
     //list.add(date); //这句话无法编译
     list.add(null);//这句可以编译，因为null没有类型信息
 }
 //可能的调用导致上界约束的add方法错误
 public void testUpperBound()
 {
      List<Timestamp> list = new ArrayList<Timestamp>();
     Date date = new Date();
     upperBound(list,date);
 }
 public void lowerBound(List<? super Timestamp> list)
 {
     Timestamp now = new Timestamp(System.currentTimeMillis());
     list.add(now);
      //Timestamp time = list.get(0); //不能编译
 }
 //可能的调用导致下界约束get方法错误
 public void testLowerBound()
 {
     List<Date> list = new ArrayList<Date>();
     list.add(new Date());
     lowerBound(list);
 }
}

class A {
}

class B extends A {
}

class C extends B {
}

5、泛型方法：是否拥有泛型方法与是否在泛型类中无关，只需在返回值前加上<T>就行

public class GenericTest {
    public <T> List<T> get(T t) {
        return new ArrayList<T>();
    }

    public void test() {
        String s = "";
        List<String> list = get(s);
        list.add("tt");
        list.add("ee");
        for(String a:list){
            System.out.println(a);
        }
    }

    public static void main(String[] args) {
        GenericTest test=new GenericTest();
        test.test();
    }
}

第23条：请不要在新代码中使用原生态类型

如果使用原生态类型，就失掉了泛型在安全性和表述性方面的所有优势