泛型

---

大家可以看看JDK帮助文档中的Class的定义，其中好多地方涉及到了<>的语法形式，这就是我们今天要讲解的泛型。
泛型是JDK1.5的所有新特性中最难深入掌握的部分，不过，我们在实际应用中不能掌握得那么深入，掌握泛型中一些最基本的内容就差不多了。

体验泛型

没有使用泛型时，只要是对象，不管是什么类型的对象，都可以存储进同一个集合中。使用泛型集合，可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，这样更方便。

• JDK1.5以前的集合类中存在什么问题？JDK5以前，对象保存到集合中就会失去其特性，取出时通常要程序员手工进行类型的强制转换，这样不可避免就会引发程序的一些安全性问题。试看以下代码：

  ArrayList collection1 = new ArrayList();collection1.add(1);collection1.add(1L);collection1.add("abc");

  代码：

  int i = (Integer)collection1.get(1);

  结果：编译要强制类型转换且运行时出错！

• JDK1.5的集合类希望你在定义集合时，明确表示你要向集合中装哪种类型的数据，无法加入指定类型以外的数据，试看如下代码：

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

  那么，这两行代码编译时就报告了语法错误：

  collection2.add(1);collection2.add(1L);

  那么，以下代码不需要再进行类型转换：

  String element = collection2.get(0);

  在JDK1.5中，你还可以按原来的方式将各种不同类型的数据装到一个集合中，但编译器会报告unchecked警告。

• 引入泛型以后，前面讲解反射的代码例子，即用反射的方式实现new String(new StringBuffer("abc"));就可以改写成如下形式了，这种情况下创建实例对象时不需要类型转换：

  Class<String> clazzString1 = String.class;Constructor<String> constructor1 = clazzString1.getConstructor(StringBuffer.class);String str2 = constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));System.out.println(str2.charAt(2));

  我是怎么知道什么情况下可以用泛型的啊？这看类的定义，只有类被定义成了泛型，才可以对其进行参数化应用。

• 泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。
  用下面的代码查看getClass()方法返回的结果已经去掉了“类型”信息：

  ArrayList<String> collection2 = new ArrayList<String>();ArrayList<Integer> collection3 = new ArrayList<Integer>();System.out.println(collection3.getClass() == collection2.getClass()); // 去类型化

  由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。

  ArrayList<Integer> collection3 = new ArrayList<Integer>();// collection3.add("abc"); // 泛型是给编译器看的collection3.getClass().getMethod("add", Object.class).invoke(collection3, "abc");System.out.println(collection3.get(0));

了解泛型

• ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语：
  
  • 整个ArrayList<E>称为泛型类型。
  • ArrayList<E>中的E称为类型变量或类型参数。
  • 整个ArrayList<Integer>称为参数化(parametered)的类型(ParameterizedType)。
  • ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数。
  • ArrayList<Integer>中的<>念着type of。
  • ArrayList称为原始类型。

• 参数化类型与原始类型的兼容性

  • 参数化类型可以引用一个原始类型的对象，编译报告警告，例如，

    Collection<String> c = new Vector();

    可不可以，不就是编译器一句话的事吗？

  • 原始类型可以引用一个参数化类型的对象，编译报告警告，例如

    Collection c = new Vector<String>();

    原来的方法接受一个集合参数，新的类型也要能传进去。

  举例说明，以下是高级程序员写的代码，使用了泛型：

  public void aa(ArrayList<String> list) {}

  以下是低级程序员写的代码，没有使用泛型，并调用高级程序员写的代码，没报错：

  public void bb() {    aa(new ArrayList());}

  说明以下代码成立：

  ArrayList<String> list = new ArrayList();

  同理，低级程序员写的代码，没使用泛型：

  public void cc(ArrayList list1) {}

  高级程序员写的代码，使用了泛型，并调用低级程序员写的代码，没报错：

  public void bb() {    cc(new ArrayList<String>());}

  说明以下代码成立：

  ArrayList list1 = new ArrayList<String>();

  小结：使用泛型时，如果两边都使用到了泛型，两边必须要一样；只用一边也是可以的。

• 参数化类型不考虑类型参数的继承关系
  泛型中的类型参数严格说明集合中装载的数据类型是什么和可以加入什么类型的数据，记住：Collection<String>和Collection<Object>是两个没有转换关系的参数化的类型。
  那么，以下代码是错误的！不写<Object>没错，写了就是明知故犯。

  Vector<String> v = new Vector<Object>(); 

  以下代码同样是错误的：

  Vector<Object> v = new Vector<String>();

  我们假设Vector<String> v = new Vector<Object>();可以的话，那么以后从v中取出的对象当作String用，而v实际指向的对象中可以加入任意的类型对象；假设Vector<Object> v = new Vector<String>();可以的话，那么以后可以向v中加入任意的类型对象，而v实际指向的集合中只能装String类型的对象。

• 编译器不允许创建泛型变量的数组，即在创建数组实例时，数组的元素不能使用参数化的类型，例如，下面语句有错误：

  Vector<Integer> vectorList[] = new Vector<Integer>[10];

思考题：下面的代码会报错误吗？

Vector v1 = new Vector<String>(); Vector<Object> v = v1;

解：不会。因为原始类型可以引用一个参数化类型的对象，所以第一句没有错误；参数化类型可以引用一个原始类型的对象，所以第二句也没有错误。但不能将两句结合起来看，如Vector<Object> v = new Vector<String>();，那么就是错误的。

泛型中的？通配符

• 问题：定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据，该方法如何定义呢？

• 错误方式：

  public static void printCollection(Collection<Object> cols) {    for(Object obj:cols) {        System.out.println(obj);    }    // cols.add("string"); // 没错    // cols = new HashSet<Date>(); // 会报告错误！}

  Collection<Object>中的Object只是说明Collection<Object>实例对象中的方法接受的参数是Object。Collection<Object>是一种具体类型，new HashSet<Date>也是一种具体类型，两者没有兼容性问题。

• 正确方式：

  public static void printCollection(Collection<?> collection) {    for(Object obj : collection) {        System.out.println(obj);    }    // collection.add(1); // 错误，因为它不知自己未来匹配就一定是Integer    System.out.println(collection.size()); // 没错，此方法与类型参数没有关系    collection = new HashSet<Date>(); // 可以}

  Collection<?> a可以与任意参数化的类型匹配，但到底匹配的是什么类型，只有以后才知道，所以，a = new ArrayList<Integer>和a = new ArrayList<String>都可以， 但a.add(new Date())或a.add("abc")都不行。

• 总结：
  使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。

泛型中的？通配符的扩展

• 限定通配符的上边界：

  • 正确：

    Vector<? extends Number> x = new Vector<Integer>();

  • 错误：

    Vector<? extends Number> x = new Vector<String>();

• 限定通配符的下边界：

  • 正确：

    Vector<? super Integer> x = new Vector<Number>();

  • 错误：

    Vector<? super Integer> x = new Vector<Byte>();

• 注意：

  • 限定通配符总是包括自己。

  • ?只能用作引用，不能用它去给其他变量赋值。

    Class<String> x = Class.forName("java.lang.String");

    编译报错，因为方法forName为

    public static Class<?> forName(String className) throws ClassNotFoundException { }

    可知此方法的返回结果是Class<?>，所以不能用它去给其他变量赋值。
    上面代码相当于：

    Class<?> y;Class<String> x = null;y = x; // 编译通过x = y; // 编译错误

    再看一个例子：

    Vector<? extends Number> y = new Vector<Integer>();Vector<Number> x = y;

    上面的代码错误，原理与Vector<Object> x11 = new Vector<String>();相似，只能通过强制类型转换方式来赋值。\

泛型集合类的综合案例

• 能写出下面的代码即代表掌握了Java的泛型集合类
  例，对下列Map集合进行遍历。

  HashMap<String, Integer> maps = new HashMap<String, Integer>();maps.put("zxx", 28);maps.put("lhm", 35);maps.put("flx", 33);

  解：

  Set<Map.Entry<String, Integer>> entrySet = maps.entrySet(); for(Map.Entry<String, Integer> entry : entrySet) {    System.out.println(entry.getKey() + ":" + entry.getValue());}

• 对在jsp页面中也经常要对Set或Map集合进行迭代：

  <c:forEach items=“${map}” var=“entry”>${entry.key}:${entry.value}</c:forEach>

定义泛型方法

Java中的泛型类型（或者泛型）类似于C++中的模板，但是这种相似性仅限于表面，Java语言中的泛型基本上完全是在编译器中实现，用于编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码，这种实现技术称为擦除（erasure）（编译器使用泛型类型信息保证类型安全，然后在生成字节码之前将其清除）。这是因为扩展虚拟机指令集来支持泛型被认为是无法接受的，这会为Java厂商升级其JVM造成难以逾越的障碍。所以，java的泛型采用了可以完全在编译器中实现的擦除方法。
例如，下面这两个方法，编译器会报告错误，它不认为是两个不同的参数类型，而认为是同一种参数类型：

public static void applyVector(Vector<Date> v1) {}/*不是重载，因为去类型化了public static void applyVector(Vector<Integer> v1) {}*/

• Java的泛型方法没有C++模板函数功能强大，java中的如下代码无法通过编译：

  <T> T add(T x,T y) {    return (T) (x+y);    //return null;}

  注意：Java程序中的普通方法、构造方法和静态方法中都可以使用泛型。方法使用泛形前，必须对泛形进行声明，语法：<T> 。用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的返回类型之前，也就是紧邻返回值之前。按照惯例，类型参数通常用单个大写字母表示。
  练习：交换数组中的两个元素的位置，用泛型方法语法定义。
  解：

  private static <T> void swap(T[] a, int i, int j) {    T tmp = a[i];    a[i] = a[j];    a[j] = tmp;}

  测试代码：

  String[] strs = new String[]{"a","b","c"};swap(strs,1,2);System.out.println(Arrays.asList(strs));

  注意：只有引用类型才能作为泛型方法的实际参数，swap(new int[]{1,3,5,4,5},3,4);语句会报告编译错误。这是因为编译器不会对new int[]{1,3,5,4,5}中的int自动拆箱和装箱了，因为new int[]{1,3,5,4,5}本身已经是对象了，你想要的有可能就是int数组呢？它装箱岂不弄巧成拙了。

• 除了在应用泛型时可以使用extends限定符，在定义泛型时也可以使用extends限定符，例如，Class.getAnnotation()方法的定义。并且可以用&来指定多个边界，如<V extends Serializable & cloneable> void method(){}
• 普通方法、构造方法和静态方法中都可以使用泛型。

• 也可以用类型变量表示异常，称为参数化的异常，可以用于方法的throws列表中，但是不能用于catch子句中。
  用下面的代码说明对异常如何采用泛型：

  private static <T extends Exception> sayHello() throws T {    try{    }catch(Exception e){       throw (T)e;    }}

• 在泛型中可以同时有多个类型参数，在定义它们的尖括号中用逗号分隔，例如：

  public static <K,V> V getValue(K key) { return map.get(key);}

泛型方法的练习题

练习1，编写一个泛型方法，自动将Object类型的对象转换成其他类型。
解：

private static <T> T autoConvert(Object obj) {    return (T)obj;}

测试代码：

Object obj = "abc";String x3 = autoConvert(obj);

泛型方法的另外一个常见应用就是调用者无需对返回值进行类型转换。
练习2，定义一个方法，可以将任意类型的数组中的所有元素填充为相应类型的某个对象。
解：

private static <T> void fillArray(T[] a, T obj) {    for(int i = 0; i < a.length; i++) {        a[i] = obj;    }}

练习3，采用自定泛型方法的方式打印出任意参数化类型的集合中的所有内容。
解：
分析：在这种情况下，前面的通配符方案要比范型方法更有效，当一个类型变量用来表达两个参数之间或者参数和返回值之间的关系时，即同一个类型变量在方法签名的两处被使用，或者类型变量在方法体代码中也被使用而不是仅在签名的时候使用，才需要使用范型方法。
使用通配符：

public static void printCollection(Collection<?> collection) {    System.out.println(collection.size());    for(Object obj : collection) {        System.out.println(obj);    }}

使用泛型方法：

public static <E> void printCollection(Collection<E> cols) {    for(E obj:cols) {        System.out.println(obj);    }}

练习4，定义一个方法，把任意参数类型的集合中的数据安全地复制到相应类型的数组中。
解：
分析：如果使用如下形式：static void copy(Collection a, Object[] b);有可能出现A类型的数据复制进B类型的数组中的情况。所以需要使用泛型方法进行定义。具体代码省略。

public static <T> void copy1(Collection<T> dest, T[] src) {}

练习5，定义一个方法，把任意参数类型的一个数组中的数据安全地复制到相应类型的另一个数组中。
解：具体代码省略。

public static <T> void copy2(T[] dest, T[] src) {}

练习6，编写一个泛形方法，接收一个任意数组，并颠倒数组中的所有元素。
解：

public <T> void reverse(T[] arr) {    int start = 0;    int end = arr.length - 1;    while(true) {        // 如果头尾两个指针碰到一块，就不要交换了        if(start >= end)            break;        T temp = arr[start];        arr[start] = arr[end];        arr[end] = temp;        start++;        end--;    }}

类型参数的类型推断

编译器判断范型方法的实际类型参数的过程称为类型推断，类型推断是相对于知觉推断(?，因为直觉推断吧！)的，其实现方法是一种非常复杂的过程。
根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：

• 当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：

  static <E> void swap(E[] a, int i, int j)

• 当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型，这很容易凭着感觉推断出来，例如：

  static <T> T add(T a, T b) 

• 当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型。例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：

  static <T> void fill(T[] a, T v) {...}fill(new Integer[3],3.5f);

• 当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型， 并且使用返回值，这时候优先考虑返回值的类型。例如，下面语句实际对应的类型就是Integer了，编译将报告错误，将变量x的类型改为float，对比eclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：

  static <T> T add(T a, T b) { return null; }int x =(3,3.5f);  

• 参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型，编译将出现问题：

  static <T> void copy(T[] a,T[] b) {...}copy(new Integer[5],new String[5]);

  static <T> void copy(Collection<T> a , T[] b) {...}copy(new Vector<String>(), new Integer[5]);

定义泛型类型

• 如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型，语法格式如下：

  public class GenericDao<E> {    public void add(E x) {    }    public E findById(int id) {        return null;    }    public void delete(E obj) {    }    public void delete(int id) {    }    public void update(E obj) {    }    // 类里面的静态方法不能使用泛型类型的变量。如果要使用，得单独独立出来，独立出来的静态泛型方法    public static <E> void update2(E obj) {    }    public E findByUserName(String name) {        return null;    }    public Set<E> findByConditions(String where) {        return null;    }}

• 类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，例如，如下两种方式都可以：

  • GenericDao<ReflectPoint> dao = null;

  • new genericDao<ReflectPoint>();

注意：

• 在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。

• 当一个变量被声明为泛型时，只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员不应该有类级别的类型参数。
  如，(类里面的)静态方法不能使用泛型类型的变量，以下代码编译错误。

  public static void update2(E obj) {}

问题：类中多个方法需要使用泛型，是使用类级别的泛型，还是使用方法级别的泛型？
答：使用类级别的泛型。

通过反射获得泛型的参数化类型

对于如下的代码：

Vector<Date> v1 = new Vector<Date>();

我们迫切地想要知道变量v1里面的泛型类型，这对以后的框架学习会有极大的帮助，但通过变量v1自己是没法知道变量里面的泛型类型的，而当把这个变量v1交给一个方法去使用时，通过这个方法是可以知道该变量里面的泛型类型的。
示例代码：

public class GenericTest {    public static void main(String[] args) {        Method applyMethod = GenericTest.class.getMethod("applyVector", Vector.class);        Type[] types = applyMethod.getGenericParameterTypes();        ParameterizedType pType = (ParameterizedType)types[0];        System.out.println(pType.getRawType()); // 打印(原始类型)：class java.util.Vector        System.out.println(pType.getActualTypeArguments()[0]); // 打印(实际化的类型参数)：class java.util.Date    }    public static void applyVector(Vector<Date> v1) {    }}

泛形的典型应用：BaseDao和反射泛型

一个项目中会有很多实体类型，那就要编写很多Dao了，这时有什么好办法来简化我们代码的编写呢？我们可以设计一个泛型类——BaseDao<T>，该泛型类提供最基本的增删改查方法，使用泛型类的原因是因为我们不知道要增删改查的具体是一个什么类型的对象，当你传递进来的T是Book，那就增删改查Book对象；你传递进来的T是Category，那就增删改查Category对象。这样的泛型类为：

public class BaseDao<T> {    public void add(T t) {        blabla...    }    public T find(String id) {        blabla...    }    public void update(T t) {        blabla...    }    public void delete(String id) {        blabla...    }} 

现在我们就要写该泛型类具体的增删改查方法了，但是以我们目前的功力，写出来是非常麻烦的，为了简化开发，我们打算导入Hibernate框架相关的jar包，来模拟Hibernate操作数据库(即使我们现在还没学习Hibernate框架)。我们来开始写这样的代码吧！

public class BaseDao<T> {    private Session session;// 首先得到与数据库会话的session    public void add(T t) {        session.save(t);    }    public T find(String id) {        // 发现写到这儿卡壳了        session.get(xxx.class, id);    }    public void update(T t) {    }    public void delete(String id) {    }} 

为什么我们写不下去了呢？——Hibernate框架根据id从数据库表里面get出来的数据，它是不知道要把这些数据封装到哪儿去的，所以应该传递给它一个Class。
我们现在遇到了一个问题，这也是一个非常重要的问题：现在Hibernate框架根据id从数据库表里面get出来数据之后，一定要传递一个Class进来，但我们在设计public T find(String id)方法的时候是不知道要传递什么Class进来的，那就没办法了，那就要由该泛型类的使用者来决定了。所以该泛型类的代码就要修改为：

public class BaseDao<T> {    private Session session;// 首先得到与数据库会话的session    private Class clazz;    public BaseDao(Class clazz) {        this.clazz = clazz;    }    public void add(T t) {        session.save(t);    }    public T find(String id) {        return session.get(clazz, id);    }    public void update(T t) {        session.update(t);    }    public void delete(String id) {        T t = session.get(clazz, id);        session.delete(t);    }} 

这样该泛型类才算写好了。前面说过一个项目中会有很多实体类型，现在我们来新建一个Book类和一个Category类。

• Book类的代码如下：

  public class Book {}

• Category类的代码如下：

  public class Category {}

接下来，我们就要编写相应的Dao了，为了让相应的Dao拥有CRUD方法，那么它们就要继承BaseDao了，并传递一个实际的类型参数进去。

• BookDao类的代码如下：

  public class BookDao extends BaseDao<Book> {    public BookDao() {        super(Book.class); // 调用父类的构造方法    }}

• CategoryDao类的代码如下：

  public class CategoryDao extends BaseDao<Category> {    public CategoryDao() {        super(Category.class);    }}

若是泛型类真如上面所写，那么在写XxxDao这样的Dao时，代码里面少不了有这样的代码：

public XxxDao() {    super(Xxx.class); // 调用父类的构造方法}

那么这样设计的泛型类就是不优雅的，为了使其优雅，我们就需要反射泛型了，这样该泛型类的代码就要修改为：

public class BaseDao<T> {    private Session session;// 首先得到与数据库会话的session    private Class clazz;    public BaseDao() {        // this; -----子类对象        // this.getClass(); -----取得BookDao.class        ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass(); // 取得泛型化了的父类(如BaseDao<Book>)，即参数化了的类型        clazz = (Class) pt.getActualTypeArguments()[0]; // 取得实际类型参数，如Book.class        // System.out.println(clazz);    }    public void add(T t) {        session.save(t);    }    public T find(String id) {        return session.get(clazz, id);    }    public void update(T t) {        session.update(t);    }    public void delete(String id) {        T t = session.get(clazz, id);        session.delete(t);    }} 

在该泛型类的无参的构造函数中，this指代的是谁呢？——this并不是指代的是自己，而是到底是谁调用了BaseDao()方法，this就指向谁。编写好这样的BaseDao之后，就会有BookDao这样的Dao去继承它，在真正地操作数据库时，总会写这样的代码：new BookDao();。用比较专业的术语来说即子类继承父类，等一会儿new子类对象的时候，根据java的new对象的机制，在new子类对象的时候，子类会调用父类的无参构造函数，所以this指代的是子类对象，到底是哪个子类对象，这无从知晓。
修改完BaseDao泛型类之后，那么像BookDao这样的Dao写起来就清爽许多了。

• BookDao类的代码如下：

  public class BookDao extends BaseDao<Book> {}

• CategoryDao类的代码如下：

  public class CategoryDao extends BaseDao<Category> {}

还需注意一个细节，即该泛型类可以限定处理的类型。

// T extends Serializable & Cloneable   限定处理的类型public class BaseDao<T extends Serializable & Cloneable> { // BaseDao处理的对象必须实现序列化接口，又实现Cloneable接口    private Session session;// 首先得到与数据库会话的session    private Class clazz;    public BaseDao() {        // this; -----子类对象        // this.getClass(); -----取得BookDao.class        ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass(); // 取得泛型化了的父类(如BaseDao<Book>)，即参数化了的类型        clazz = (Class) pt.getActualTypeArguments()[0]; // 取得实际类型参数，如Book.class        // System.out.println(clazz);    }    public void add(T t) {        session.save(t);    }    public T find(String id) {        return session.get(clazz, id);    }    public void update(T t) {        session.update(t);    }    public void delete(String id) {        T t = session.get(clazz, id);        session.delete(t);    }} 

这时要让程序不报错，得修改Book类和Category类的代码，改后如下：

• Book类的代码如下：

  public class Book implements Serializable, Cloneable {}

• Category类的代码如下：

  public class Category implements Serializable, Cloneable {}