axr1985lazy

黑马程序员——其他5：泛型

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1. 概述

1.1 问题的引出

我们在前面的内容中主要介绍了ArrayList、LinkedList、HashSet和TreeSet集合类及其使用方法、特点及底层数据结构等内容。下面我们主要以ArrayList为例，通过下面的代码来引出本篇博客的主题——泛型。这里需要声明一点，泛型应用并不仅限于集合框架中，这里只是以集合类为例进行说明。
代码1：

import java.util.*;


class GenericDemo
{
	public static void main(String[] args)
	{
		ArrayList al = new ArrayList();


		//先存储若干字符串对象
		al.add("Sun");
		al.add("Mountain");
		al.add("Restaurant");


		/*
		//再存储两个Integer对象
		al.add(new Integer(56));
		al.add(1010);//自动装箱
		*/


		for(ListIterator li = al.listIterator(); li.hasNext(); )
		{
			String str = (String)li.next();
			//打印字符串本身，以及字符串的长度
			System.out.println(str+" : "+str.length());
		}
	}
}

将中间两行代码注释掉以后的运行结果为：
Sun : 3
Mountain : 8
Restaurant : 10
但是将注释符号去掉以后，虽然编译成功，但是运行时，却抛出了异常，提示如下：
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.StringatGenericDemo.main(GenericDemo.java:23)
异常提示告诉我们：Integer类型对象无法转换为String类型。这是显然的，因为两种类型之间如果要进行转换，必须具有继承或实现关系，而Integer类与String类之间并不具备这样的关系。
那么上述例子所反映的问题是：能否向某一个集合中存储多种类型的对象？通常情况下这种做法是不合理的。这是因为，我们将一些对象存储到集合中时，在底层会将每个元素均向上转型为Object类型对象，因此我们在取出元素时需要进行向下转型，并对这些元素进行一些针对性地操作。而这里所说的针对性的操作，就比如像代码1中那样获取字符串长度等。而如果向集合中存储了多种类型的对象，我们就无法将元素准确的转型为其原来的类型。
因此为了避免出现ClassCastException——类型转换异常——最安全的做法就是向一个集合中只存储某一种类型的对象。而在1.5版本以前，通常程序员都是主观判断集合的类型问题，那么为了提高开发效率，在1.5版本以后增加了泛型机制，让编译器帮助我们检查此类问题，以此在提高安全性的同时减少了程序员的工作负担。我们之前也提到过，JDK版本的升级一般有三种情况：简化书写、提高效率与提高安全性，那么这一改进就是为了提高安全性。

1.2 问题的解决

那么泛型机制是如何解决集合的类型问题的呢？我们可以参考数组的定义方式。阅读下面的代码，
代码2：

class GenericDemo2
{
	public static void main(String[] args) 
	{
		int[] arr = new int[3];


		arr[0] = 37;
		arr[1] = 34.5;
	}
}

编译时抛出了异常：
GenericDemo2.java:8: 错误: 不兼容的类型: 从double转换到int可能会有损失
arr[1] = 34.5;
^
1 个错误
那么这个异常的产生是显然的，因为我们在定义arr数组的时候，就已经明确其类型为int型数组，换句话说，我们不能向该数组存储除int以外的其他类型的变量，在编译期间就排除了类型问题。而泛型机制的基本原理与数组类似，就是在定义集合时就明确存储元素的类型，也是在编译时期，从语法角度，杜绝了类型问题。

1.3 泛型的定义格式

我们以代码1中ArrayList集合对象为例，如果我们希望向集合中存储String类型的对象，其定义格式为：
ArrayList al = new ArrayList();
集合类名后的尖括号内，定义的就是元素的类型。上述代码的意思是：定义一个ArrayList集合，而该集合只能存储String类型的对象。那么我们对代码1进行如上修改，
代码3：

import java.util.*;


class GenericDemo3
{
	public static void main(String[] args) 
	{
		//泛型
		ArrayList al = new ArrayList();


		//先存储若干字符串对象
		al.add("Sun");
		al.add("Mountain");
		al.add("Restaurant");


		//再存储两个Integer对象
		al.add(new Integer(56));


		for(ListIterator li = al.listIterator(); li.hasNext(); )
		{
			String str = (String)li.next();
			System.out.println(str+" : "+str.length());
		}
	}
}

此时，编译时期就抛出了异常：
GenericDemo3.java:17: 错误: 对于add(Integer), 找不到合适的方法
al.add(new Integer(56));
^
方法Collection.add(String)不适用
(参数不匹配; Integer无法转换为String)
方法List.add(String)不适用
(参数不匹配; Integer无法转换为String)
方法AbstractCollection.add(String)不适用
(参数不匹配; Integer无法转换为String)
方法AbstractList.add(String)不适用
(参数不匹配; Integer无法转换为String)
方法ArrayList.add(String)不适用
(参数不匹配; Integer无法转换为String)
注: 某些消息已经过简化; 请使用 -Xdiags:verbose重新编译以获得完整输出
1 个错误
此时就将集合的类型问题，从运行时期转移到了编译时期，那么编译失败，就需要修改代码，就可以保证在运行期间不会再出现此类问题，从而避免了安全问题。既然代码3中我们限定了ArrayList集合只能存储字符串对象，那么在通过for循环获取元素时是不是不需要，进行向下转型动作了呢？就像下面的代码所示，
代码4：

import java.util.*;


class GenericDemo4
{
	public static void main(String[] args) 
	{
		//泛型
		ArrayList al = new ArrayList();


		//先存储若干字符串对象
		al.add("Sun");
		al.add("Mountain");
		al.add("Restaurant");


		for(ListIterator li = al.listIterator(); li.hasNext(); )
		{
			//去掉向下转型的动作
			String str = li.next();
			System.out.println(str+" : "+str.length());
		}
	}
}

编译器件依然会报出错误：
GenericDemo4.java:18: 错误: 不兼容的类型
String str = li.next();
^
需要: String
找到: Object
1 个错误
实际上，上述这个问题是出在了Iterator迭代器上。迭代器作为操作集合中元素的工具，也应对其可操作的对象类型进行限定——只能操作其所属集合的可操作引用数据类型。那么同理为迭代器对象添加泛型，修改后的最终代码为，
代码5：

import java.util.*;


class GenericDemo5
{
	public static void main(String[] args) 
	{
		//迭代器也定义泛型
		ArrayList al = new ArrayList();


		//存储若干字符串对象
		al.add("Sun");
		al.add("Mountain");
		al.add("Restaurant");


		for(ListIterator li = al.listIterator(); li.hasNext(); )
		{
			String str = li.next();
			System.out.println(str+" : "+str.length());
		}
	}
}

运行结果与代码1相同：
Sun : 3
Mountain : 8
Restaurant : 10
如果大家自行尝试运行上述代码就会发现，不仅没再出现编译时期的错误提示，并且也没有出现如下警告：
注: GenericDemo5.java使用了未经检查或不安全的操作。
注: 有关详细信息, 请使用 -Xlint:unchecked重新编译。
这是因为，上述代码已经不存在类型安全问题，因此编译器不再作出警告。

1.4 总结

那么泛型机制的优点可总结为以下两点：
(1) 将运行时期出现的ClassCastException，转移到了编译时期，方便程序员解决问题，减少运行时可能出现的安全问题。
(2) 避免了进行强制类型转换，简化代码的书写。

2. 理解泛型

2.1 泛型术语简介

在介绍泛型的应用以前，为帮助大家理解，我们首先说一说泛型技术中常用的一些术语，这里以ArrayList为例：
(1) 将泛型定义在类上时，比如ArrayList，就称之为泛型类型，其中的E称为类型变量或类型参数；
(2) 若指定了具体的泛型类型，比如ArrayList，则称为参数化的类型（Parametered Type），其中的Integer称为实际类型参数或类型参数的实例；
(3) ArrayList用英语读作：“ArrayList typeof Integer”；
(4) 未定义任何泛型的ArrayList称为原始类型。

2.2 泛型的应用场景

既然泛型机制具有可以提高代码的安全性以及简化代码书写的优点，那么应该在什么情况下使用泛型呢？通常情况下，集合框架中的类，尤其是集合类，都会使用泛型机制。比如，Collection接口的API文档中，Collection接口名后接一对尖括号，其内包含一个大写字母E，这也是泛型机制的体现。可能有朋友会问，既然尖括号内需要定义引用数据类型，那么E又是什么类型呢？实际上这里的E是一种泛指，在定义这一接口的时候，它并没有限定该接口所能操作的引用数据类型，而是需要在程序员创建Collection实现类对象时再去告诉编译器具体将要操作的引用数据类型是什么，它可以是String、Integer、Double或者自定义类型。
大家可以这样类比地理解泛型，当我们调用某个方法时，需要向其传递某个参数，这个参数可以是对象也可以是基本数据类型变量，那么泛型也好比是传递参数，只不过这个参数是引用数据类型名称而已。再比如，大家去查阅ArrayList类的API文档，类名后同样有一对尖括号，内含一个字母E，而在方法摘要中add方法的参数列表的变量类型也是E，这也就说明了，当我们去创建一个ArrayList对象时，尖括号中声明了什么类型，该集合对象的部分方法（参数列表中变量类型为E的方法）所操作的变量就是什么类型。所以，我们将这个E称为类型变量，或者类型参数，由它来接收传递的具体引用数据类型。
说到这，有的朋友可能会感到有些困惑，API文档中类名后有一对尖括号用于声明该类可操作的引用数据类型，而在前述代码5中，创建ArrayList对象时也在类名后添加一对尖括号，这两种泛型的使用有什么区别和联系呢？实际上API文档是通过javadoc程序，以html文件的形式呈现类的各种信息（包括成员方法、字段、子父类等等），因此API文档就相当于是我们定义的类。我们以集合类为例，假设我们现在需要自己开发一种集合类A，那么在定义A类的时候，我们事先是不能知道，使用这个类对象的程序员会向这个集合存储什么类型的对象，因此就在类名后用E去泛指各种类型。而当程序员创建A类对象时，通过类名后的尖括号声明A类集合所存储元素的具体类型以后，才能在运行时最终确定。那么这就是定义类时的泛型声明和创建对象时的泛型声明之间的关系。

2.3 泛型机制原理简述

既然定义泛型可以将运行时期可能发生的错误，转移到编译时期，由编译器提醒我们类型错误，那么实际上定义的泛型就是提供给编译器使用的。编译器从语法的角度，挡住程序员向集合中存储非法类型的元素，以此来提高代码的安全性。
但是，编译器在完成编译以后，就会自动去掉集合的“类型信息”，也就是泛型类型，使程序的运行效率不受影响。比如以下两行代码
ArrayList al1 = new ArrayList()；
ArrayList al2 = new ArrayList();
虽然，两个ArrayList对象定义了不同的泛型类型，但是在完成编译以后，由于编译器将两者的类型信息去掉了，因此它们在内存中的字节码对象（Class对象）是完全相同的，如下代码所示，
代码6：

import java.lang.reflect.Constructor;
import java.util.ArrayList;

public class GenericDemo6 {
	public static void main(String[] args) throws Exception {		
		ArrayList al1 = new ArrayList();
		ArrayList al2 = new ArrayList();
		System.out.println(al1.getClass().equals(al2.getClass()));
	}
}

执行结果为：
true
执行结果表明，al1和al2指向的两个对象，又同时对应了内存中同一份字节码，因为一个类的“.class”文件只能被加载一次。由此可知，同一种集合类对象尽管定义了不同的泛型类型，但是由于在编译期间编译器去掉了类型信息，因此加载到内存中的字节码对象均是原始字节码对象（即没有定义任何泛型的字节码对象）。那么这种在编译期间去掉类型信息的动作，称为去类型化。我们可以利用去类型化的特点，利用反射技术，向定义有泛型的集合中存储非泛型类型的对象，这一部分演示请参考“3.5节泛型在反射中的应用”。
上面啰嗦了这么多，简单总结一下：
(1) 定义类时，尖括号用于接收类型，对外声明该类可能将会操作某个类型的变量，但定义该类时并不确定；
(2) 创建对象时，尖括号用于传递类型，用于在运行时最终确定该对象将操作哪种类型的对象；
(3) 由于编译器去类型化的特点，在源代码中定义了泛型的对象，在运行期间加载到内存中的字节码对象就是原始类型，并不会因为定义了泛型而有所不同。
最后需要强调的是，尖括号中只能传递引用数据类型，而不能传递基本数据类型。

2.4 泛型类型的兼容性

(1) 参数化类型可以引用一个原始类型的对象

比如，代码“Collection coll = new Vector();”，是可以通过编译并执行的，只不过会报出编译时警告。假设，当前的编译器版本和JRE版本均为1.5，然后在源代码中调用了一个JDK1.4版本的一个方法，该方法会返回一个集合。由于JDK1.4版本时还没有引入泛型机制，因此该方法返回的集合中也肯定没有定义泛型。那么为了兼顾调用JDK1.4版本方法的需求，以及泛型机制优势的发挥，参数类型时可以引用一个原始类型的对象的。如果没有这样的兼容性，那么为了泛型机制的应用，JDK1.4版本以前的方法就都无法使用了。

(2) 原始类型引用可以指向一个参数化类型对象

比如，代码“Collection coll = new Vector();”，同样可以通过编译并执行，但也会报出编译时警告。假设，需要调用JDK1.4版本以前的一个方法，该方法的参数类型中需要传递一个集合对象，比如这样的一个方法“public void fun(Collection coll)”，显然集合的引用中并没有定义泛型。当我们在1.5版本的编译环境下，就可以在调用该方法的同时传递一个参数化类型集合对象。

(3) 参数化类型不考虑类型参数间的继承关系

阅读下面两行代码，
Vector vec = new Vector