泛型的学习

主要参考：

http://blog.csdn.net/lonelyroamer/article/details/7868820

一、何为泛型？java为何要引入泛型

泛型的定义：

泛型是JDK 1.5的一项新特性，它的本质是参数化类型（Parameterized Type）的应用，也就是说所操作的数据类型被指定为一个参数，在用到的时候在指定具体的类型。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。

java为何要引入泛型：

泛型思想早在C++语言的模板（Templates）中就开始生根发芽，在Java语言处于还没有出现泛型的版本时，只能通过Object是所有类型的父类和类型强制转换两个特点的配合来实现类型泛化。例如在哈希表的存取中，JDK 1.5之前使用HashMap的get()方法，返回值就是一个Object对象，由于Java语言里面所有的类型都继承于java.lang.Object，那Object转型为任何对象成都是有可能的。但是也因为有无限的可能性，就只有程序员和运行期的虚拟机才知道这个Object到底是个什么类型的对象。在编译期间，编译器无法检查这个Object的强制转型是否成功，如果仅仅依赖程序员去保障这项操作的正确性，许多ClassCastException的风险就会被转嫁到程序运行期之中。

二、泛型的使用

泛型的参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。下面看看具体是如何定义的。

1、泛型类的定义和使用

一个泛型类（generic class）就是具有一个或多个类型变量的类。定义一个泛型类十分简单，只需要在类名后面加上<>，再在里面加上类型参数：

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

该如何使用呢

public static void main(String[] args) throws ClassNotFoundException {
	Pair<String> pair=new Pair<String>("Hello");
	String str=pair.getValue();
	System.out.println(str);
	pair.setValue("World");
	str=pair.getValue();
	System.out.println(str);
}

2、泛型接口的定义和使用

定义泛型接口和泛型类差不多，看下面简单的例子：

interface Show<T,U>{
	void show(T t,U u);
}

class ShowTest implements Show<String,Date>{
	@Override
	public void show(String str,Date date) {
		System.out.println(str);
		System.out.println(date);
	}
}

简单的测试一下：

public static void main(String[] args) throws ClassNotFoundException {
	ShowTest showTest=new ShowTest();
	showTest.show("Hello",new Date());
}

3、泛型方法的定义和使用

泛型类在多个方法签名间实施类型约束。之所以声明泛型方法，一般是因为您想要在该方法的多个参数之间宣称一个类型约束。

举个简单的例子：

public static void main(String[] args) throws ClassNotFoundException {
		String str=get("Hello", "World");
		System.out.println(str);
}

public static <T, U> T get(T t, U u) {
	if (u != null)
		return t;
	else
		return null;
}

三、泛型变量的类型限定

在上面，我们简单的学习了泛型类、泛型接口和泛型方法。我们都是直接使用<T>这样的形式来完成泛型类型的声明。

有的时候，类、接口或方法需要对类型变量加以约束。

public static <T> T get(T t1,T t2) {
    if(t1.compareTo(t2)>=0)//编译出错
         return t1;
}

因为，在编译之前，也就是我们还在定义这个泛型方法的时候，我们并不知道这个泛型类型T，到底是什么类型，所以，只能默认T为原始类型Object。所以它只能调用来自于Object的那几个方法，而不能调用compareTo方法。

可我的本意就是要比较t1和t2，怎么办呢？这个时候，就要使用类型限定，对类型变量T设置限定（bound）来做到这一点。

我们知道，所有实现Comparable接口的方法，都会有compareTo方法。所以，可以对<T>做如下限定：

public static <T extends Comparable> T get(T t1,T t2) { //添加类型限定
		if(t1.compareTo(t2)>=0)
		    return t1;
}

类型限定在泛型类、泛型接口和泛型方法中都可以使用，不过要注意下面几点：

1、不管该限定是类还是接口，统一都使用关键字 extends

2、可以使用&符号给出多个限定，比如

 public static <T extends Comparable&Serializable> T get(T t1,T t2)

3、如果限定既有接口也有类，那么类必须只有一个，并且放在首位置

public static <T extends Object&Comparable&Serializable> T get(T t1,T t2)

四、java类型的实现方法：类型擦除

为什么说Java的泛型是伪泛型呢？因为，在编译期间，所有的泛型信息都会被擦除掉。

1、理解类型擦除

Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器在编译的时候去掉。这个过程就称为类型擦除。

如在代码中定义的List<object>和List<String>等类型，在编译后都会编程List。JVM看到的只是List，而由泛型附加的类型信息对JVM来说是不可见的。Java编译器会在编译时尽可能的发现可能出错的地方，但是仍然无法避免在运行时刻出现类型转换异常的情况。类型擦除也是Java的泛型实现方法与C++模版机制实现方式之间的重要区别。

2、可以通过两个简单的例子，来证明java泛型的类型擦除。

例1、

public class Test4 {
	public static void main(String[] args) {
		ArrayList<String> arrayList1=new ArrayList<String>();
		arrayList1.add("abc");
		ArrayList<Integer> arrayList2=new ArrayList<Integer>();
		arrayList2.add(123);
		System.out.println(arrayList1.getClass()==arrayList2.getClass());
	}
}

在这个例子中，我们定义了两个ArrayList数组，不过一个是ArrayList<String>泛型类型，只能存储字符串。一个是ArrayList<Integer>泛型类型，只能存储整形。最后，我们通过arrayList1对象和arrayList2对象的getClass方法获取它们的类的信息，最后发现结果为true。说明泛型类型String和Integer都被擦除掉了，只剩下了原始类型。

例2、

public class Test4 {
	public static void main(String[] args) throws IllegalArgumentException, SecurityException, IllegalAccessException, InvocationTargetException, NoSuchMethodException{
		ArrayList<Integer> arrayList3=new ArrayList<Integer>();
		arrayList3.add(1);//这样调用add方法只能存储整形，因为泛型类型的实例为Integer
		arrayList3.getClass().getMethod("add", Object.class).invoke(arrayList3, "asd");
		for (int i=0;i<arrayList3.size();i++) {
			System.out.println(arrayList3.get(i));
		}
	}

在程序中定义了一个ArrayList泛型类型实例化为Integer的对象，如果直接调用add方法，那么只能存储整形的数据。不过当我们利用反射调用add方法的时候，却可以存储字符串。这说明了Integer泛型实例在编译之后被擦除了，只保留了原始类型。

3、类型擦除后保留的原始类型

在上面，两次提到了原始类型，什么是原始类型？原始类型（raw type）就是擦除去了泛型信息，最后在字节码中的类型变量的真正类型。无论何时定义一个泛型类型，相应的原始类型都会被自动地提供。类型变量被擦除（crased），并使用其限定类型（无限定的变量用Object）替换。

例：

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

类型擦除后：

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

因为在Pair<T>中，T是一个无限定的类型变量，所以用Object替换。其结果就是一个普通的类，如同泛型加入java变成语言之前已经实现的那样。在程序中可以包含不同类型的Pair，如Pair<String>或Pair<Integer>，但是，擦除类型后它们就成为原始的Pair类型了，原始类型都是Object。

从上面的那个例2中，我们也可以明白ArrayList<Integer>被擦除类型后，原始类型也变成了Object，所以通过反射我们就可以存储字符串了。

4、限定参数类型的泛型的类型擦除

如果类型变量有限定，那么原始类型就用第一个边界的类型变量来替换。如下：

public class Pair<T extends Comparable& Serializable> {}

那么原始类型就是Comparable

注意：

如果Pair这样声明public class Pair<T extends Serializable&Comparable> ，那么原始类型就用Serializable替换，而编译器在必要的时要向Comparable插入强制类型转换。为了提高效率，应该将标签（tagging）接口（即没有方法的接口）放在边界限定列表的末尾。

5、区分原始类型和泛型变量的类型

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

在不指定泛型的情况下，泛型变量的类型为 该方法中的几种类型的同一个父类的最小级，直到Object。

在指定泛型的时候，该方法中的几种类型必须是该泛型实例类型或者其子类。

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

                /**指定泛型的时候*/
		int a=Test2.<Integer>add(1, 2);//指定了Integer，所以只能为Integer类型或者其子类
		int b=Test2.<Integer>add(1, 2.2);//编译错误，指定了Integer，不能为Float
		Number c=Test2.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Float
	}
	
	//这是一个简单的泛型方法
	public static <T> T add(T x,T y){
		return y;
	}
}

五、类型擦除引起的问题及解决方法

因为种种原因，Java不能实现真正的泛型，只能使用类型擦除来实现伪泛型，这样虽然不会有类型膨胀的问题，但是也引起了许多新的问题。所以，Sun对这些问题作出了许多限制，避免我们犯各种错误。

1、先检查，在编译，以及检查编译的对象和引用传递的问题

既然说类型变量会在编译的时候擦除掉，那为什么我们往ArrayList<String> arrayList=new ArrayList<String>();所创建的数组列表arrayList中，不能使用add方法添加整形呢？不是说泛型变量Integer会在编译时候擦除变为原始类型Object吗，为什么不能存别的类型呢？既然类型擦除了，如何保证我们只能使用泛型变量限定的类型呢？

java是如何解决这个问题的呢？java编译器是通过先检查代码中泛型的类型，然后再进行类型擦除，在进行编译的。

举个栗子：

public static  void main(String[] args) {
		ArrayList<String> arrayList=new ArrayList<String>();
		arrayList.add("123");
		arrayList.add(123);//编译错误
}

在上面的程序中，使用add方法添加一个整形，在eclipse中，直接就会报错，说明这就是在编译之前的检查。因为如果是在编译之后检查，类型擦除后，原始类型为Object，是应该运行任意引用类型的添加的。可实际上却不是这样，这恰恰说明了关于泛型变量的使用，是会在编译之前检查的。

2、自动类型转换

因为类型擦除的问题，所以所有的泛型类型变量最后都会被替换为原始类型。这样就引起了一个问题，既然都被替换为原始类型，那么为什么我们在获取的时候，不需要进行强制类型转换呢？看下ArrayList和get方法：

public E get(int index) {
	RangeCheck(index);
	return (E) elementData[index];
}

看以看到，在return之前，会根据泛型变量进行强转。

3、泛型类型变量不能是基本数据类型

不能用类型参数替换基本类型。就比如，没有ArrayList<double>，只有ArrayList<Double>。因为当类型擦除后，ArrayList的原始类型变为Object，但是Object类型不能存储double值，只能引用Double的值。

4、运行时类型查询

举个栗子：

ArrayList<String> arrayList=new ArrayList<String>();

因为类型擦除之后，ArrayList<String>只剩下原始类型，泛型信息String不存在了

那么，运行时进行类型查询的时候使用下面的方法是错误的。

if( arrayList instanceof ArrayList<String>)

java限定了这种类型查询的方式：

if( arrayList instanceof ArrayList<?>)

5、数组

不能声明参数化类型的数组。如：

Pair<String>[] table = newPair<String>(10); //ERROR

这是因为擦除后，table的类型变为Pair[]，可以转化成一个Object[]。然后就可以向数组中添加非String类型的变量。

6、泛型类型的实例化

不能实例化泛型类型。如：

    first = new T(); //ERROR

是错误的，类型擦除会使这个操作做成new Object()。

7、泛型在静态方法和静态类中的使用

泛型类中的静态方法和静态变量不可以使用泛型类所声明的泛型类型参数

举例说明：

    public class Test2<T> {  
        public static T one;   //编译错误  
        public static  T show(T one){ //编译错误  
            return null;  
        }  
    }  

因为泛型类中的泛型参数的实例化是在定义对象的时候指定的，而静态变量和静态方法不需要使用对象来调用。对象都没有创建，如何确定这个泛型参数是何种类型，所以当然是错误的。

但是要注意区分下面的一种情况：

    public class Test2<T> {  
      
        public static <T >T show(T one){//这是正确的  
            return null;  
        }  
    }  

因为这是一个泛型方法，在泛型方法中使用的T是自己在方法中定义的T，而不是泛型类中的T。（这个泛型类中的T完全可以去掉）

六、最后几点建议

1、不要在代码中使用原生态类型，必须使用泛型类型

举个栗子：

“ArrayList”就是原生态类型，“ArrayList<String>”就是泛型类型。

2、列表优于数组

以下代码片段是合法的：

Object[] objectArray = new Long[1];
objectArray[0] = "hello world!";

以下代码片段则不合法：

List<Object> list = new ArrayList<Long>();
list.add("hello World!");//error

这其中无论哪种方法，都不能将String放进Long容器中，但是利用数组，你会在运行时发现所犯的错误；利用泛型列表，则可以在编译时发现错误。我们当然希望在编译时发现错误了。

3、利用有限制通配符来提升API的灵活性(多态的实现)

如:

public void push(Iterable<? extends E> src){
//src的具体操作
};

4、优先考虑类型安全的异构容器

泛型最常用于容器，如Set和Map，以及单元素的容器。在这些用法中，它都充当被参数化了容器，这样限制你每个容器只能有固定数目的类型参数。

有时候你会需要更多的灵活性，那么可以使用Class<T>来指定参数类型，使得传入和取出的数据类型相对应。