Java泛型

一、Java泛型

Java泛型是JKD1.5引入的一个新特性，泛型提供了编译时安全监测机制，该机制允许程序员在编译时检测非法的类型。
泛型的本质是参数化类型，即所操作的数据类型被指定为一个参数。

泛型一般有三种使用方式：

1. 泛型类

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{ 

    private T key;

    public Generic(T key) { 
        this.key = key;
    }

    public T getKey(){ 
        return key;
    }
}

如何实例化泛型类：

Generic<Integer> genericInteger = new Generic<Integer>(123456);

2. 泛型接口

public interface Generator<T> {
    public T method();
}

实现泛型接口，不指定类型：

class GeneratorImpl<T> implements Generator<T>{
    @Override
    public T method() {
        return null;
    }
}

实现泛型接口，指定类型：

class GeneratorImpl<T> implements Generator<String>{
    @Override
    public String method() {
        return "hello";
    }
}

3. 泛型方法

   public static < E > void printArray( E[] inputArray )
   {         
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }

使用：

// 创建不同类型数组： Integer, Double 和 Character
Integer[] intArray = { 1, 2, 3 };
String[] stringArray = { "Hello", "World" };
printArray( intArray  ); 
printArray( stringArray  ); 

二、类型擦除

Java的泛型基本上都是在编译器上实现，在生成的字节码中不包含泛型中的类型信息，使用泛型的时候加上类型参数，在编译期去除。

1. 证明Java类型擦除
   例.原始类型相等

public class Test {
    public static void main(String[] args) {

        ArrayList<String> list1 = new ArrayList<String>();
        list1.add("abc");

        ArrayList<Integer> list2 = new ArrayList<Integer>();
        list2.add(123);

        System.out.println(list1.getClass() == list2.getClass());
    }
}

结果为 true 说明反省类型 String 和 Integer 都被擦除，只留下原始类型

例.通过反射添加其它类型元素

public class Test {
    public static void main(String[] args) throws Exception {

        ArrayList<Integer> list = new ArrayList<Integer>();

        list.add(1);  //这样调用 add 方法只能存储整形，因为泛型类型的实例为 Integer

        list.getClass().getMethod("add", Object.class).invoke(list, "asd");

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

如果直接调用 add() 方法，只能存储整数类型，但是通过反射调用 add() 方法，可以存储字符串，说明 Integer 泛型实例在编译之后被擦除，只保留了原始类型。

2. 类型擦除后保留的原始类型
   原始类型就是擦除了泛型信息，最后在字节码中的类型变量的真正类型，无论何时定义一个泛型，相应的原始类型都会被自动提供，类型变量擦书，并使用其限定类型（无限定的变量用Object）替换
   例.原始类型Object

class Pair<T> {  
    private T value;  
    public T getValue() {  
        return value;  
    }  
    public void setValue(T  value) {  
        this.value = value;  
    }  
}  

Pair的原始类型为:

class Pair {  
    private Object value;  
    public Object getValue() {  
        return value;  
    }  
    public void setValue(Object  value) {  
        this.value = value;  
    }  
}

在 Pair 中，T是一个无限定的类型变量，所以用 Object 替换，其结果就是一个普通类。在程序中可以包含不同类型的 Pair ，如 Pair 或 Pair ，但是擦除类型后他们的就成为原始的 Pair 类型了，原始类型都是 Object。

如果类型变量有限定，那么原始类型就用第一个边界的类型变量类替换。
比如： Pair这样声明的话

public class Pair<T extends Comparable> {}

那么原始类型就是 Comparable 。

在调用泛型方法时，可以指定泛型，也可以不指定泛型。

• 在不指定泛型的情况下，泛型变量的类型为该方法中的几种类型的同一父类的最小级，直到 Object
• 在指定泛型的情况下，该方法的几种类型必须是该泛型的实例的类型或者其子类

public class Test {  
    public static void main(String[] args) {  

        /**不指定泛型的时候*/  
        int i = Test.add(1, 2); //这两个参数都是Integer，所以T为Integer类型  
        Number f = Test.add(1, 1.2); //这两个参数一个是Integer，以风格是Float，所以取同一父类的最小级，为Number  
        Object o = Test.add(1, "asd"); //这两个参数一个是Integer，以风格是Float，所以取同一父类的最小级，为Object  

        /**指定泛型的时候*/  
        int a = Test.<Integer>add(1, 2); //指定了Integer，所以只能为Integer类型或者其子类  
        int b = Test.<Integer>add(1, 2.2); //编译错误，指定了Integer，不能为Float  
        Number c = Test.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Float  
    }  

    //这是一个简单的泛型方法  
    public static <T> T add(T x,T y){  
        return y;  
    }  
}

其实在泛型类中，不指定泛型的时候，也差不多，只不过这个时候的泛型为 Object，就比如 ArrayList 中，如果不指定泛型，那么这个 ArrayList 可以存储任意的对象。

public static void main(String[] args) {  
    ArrayList list = new ArrayList();  
    list.add(1);  
    list.add("121");  
    list.add(new Date());  
}