文章导读

【前面讲过的集合类可以存储不同类型的对象，当不同类型的对象存储到同一集合类时，就有可能会发生对象使用异常问题。例如，在一个ArrayList集合类中既存储了String对象（字符串），又存储了Integer对象（整型）时，由于ArrayList类把存储的对象都转换为Object对象，因此在使用对象时就无法判断该对象是String，还是Integer对象，当把Integer对象作为String对象使用时，就会发生异常。通过泛型机制就可以避免上述问题的发生。】

在讲述泛型概念之前，先看一段代码。

package adddemo;
import java.util.ArrayList;
import java.util.List;
public class LinkedListAddDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("first");
        list.add("second");
        list.add("third");
        System.out.println(list);
        String  temp = (String)list.get(0);
        System.out.println("get(0): " + temp);
    }
}

在上面的代码段中，存入list容器的对象是String对象（字符串类型），因为对象被加入集合容器时都被转化为Object类型，因此在调用list的get方法时，需要把Object类型强制转换为字符串类型，这种类型转换称为向下类型转换。向下类型转换时，如果父类不能转换为子类，则抛出ClassCastExceptionClassCastException异常。在泛型出现之前，这种现象在编程中会经常发生，因为有时程序员在获取集合元素时，并不能够完全明确集合中存储的是属于什么类型的元素。

上面的代码段存在类型强制转换的问题，下面的代码段则存在对象使用异常的问题。

import java.util.ArrayList;
import java.util.List;
public class GenericTest {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List list = new ArrayList();
        list.add("qqyumidi");
        list.add("corn");
        list.add(100);
        for (int i = 0; i < list.size(); i++) {
            String name = (String) list.get(i); // 1
            System.out.println("name:" + name);
        }
    }
 
}

上面的代码段定义了一个List类型的集合，先向其中加入了两个String对象，随后又加入一个Integer对象。这是完全可以的，因为List类将加入的元素转换为Object类型。在之后遍历List的循环中，并没有判断从List集合中获取的对象是什么类型，全部直接作为String对象使用，导致出现程序异常。

从前面的两个代码段中可以看出，当将一个对象放入集合类时，集合类会将对象转换为Object类型，并不会记住此对象的原类型，当再次从集合类取出此对象时，此对象为Object类型，需要强制转换为原类型方可使用。

那么有什么办法可以让装入集合容器的数据保存自己的类型，而不被转化为Object对象呢？这就需要用到JDK  5.0后支持的一项新功能——Java泛型。

泛型在Java代码编译时被用到，是提供给编译器语法检查用的。泛型允许用户在定义类、类方法、形式参数、成员变量时，指定它为通用类型，也就是数据类型可以是任意的类型，如“List<?> list=null;”,具体调用的时候，要将通用类型转换成指定的类型使用。

泛型这个概念类似于大学自习时的占座行为，在课桌上丢一本书或某个相关的标记，表明此座位已经有人了，这个座位上究竟是那位同学，可能只有到上课才知道。泛型也就是给参数类型指定的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。

下面结合List集合的定义，对泛型概念进一步说明。

图1  List集合定义

从List定义可以看出，接口List后跟有<E>，这个E就与方法中的形参类似，E限定了放在容器中元素的类型。

采用泛型之后，前面的第一个代码段就不再需要做类型转换了。

package adddemo;
import java.util.ArrayList;
import java.util.List;
public class LinkedListAddDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("first");
        list.add("second");
        list.add("third");
        System.out.println(list);
        String  temp = list.get(0);
        System.out.println("get(0): " + temp);
    }
}

代码实例化List集合时，将List<E>中的E替换为String类型，同时new运算符后面的ArrayList<E>中的E也要替换为String类型。这样，在调用List集合的get方法获取字符串对象时，就不需要做类型的强制转换了。

采用泛型后，前面的第二个代码段List只能加入String对象元素，加入其它类型的元素则编译报错。

import java.util.ArrayList;
import java.util.List;
public class GenericTest {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<String> list = new ArrayList<String>();
        list.add("qqyumidi");
        list.add("corn");
        //list.add(100);  //提示编译错误
        for (int i = 0; i < list.size(); i++) {
            String name = (String) list.get(i); // 1
            System.out.println("name:" + name);
        }
    }
 
}

下面从泛型的声明和泛型的使用来学习泛型的相关内容。

1、泛型的声明

在定义一个泛型的时候，在<>之间定义形式类型参数，例如，“class  Point<E>”，其中E不代表值，而是表示类型。

声明一个具有泛型的Point类，代码如下：

package com.milihua.generic;
public class Point<E> {
    // var的类型由E指定
    private E var ;  
    public Point(){         
    } 
   // 返回值的类型由外部决定
    public E getVar(){   
        return var ; 
    } 
   // 设置的类型也由外部决定
    public void setVar(E var){   
        this.var = var ; 
    } 
}

代码定义了Point类，Point类名后面有泛型参数<E>，因此外部代码在实例化Point类时，需要传入类型参数，类中所有的E在编译过程中都会被传入的参数替换。

2、泛型的使用

使用具有泛型定义的类，在外部实例化该类时，需要传入实际的类型参数用于指定该类所使用的数据类型。如果没有指定传入的参数，编译器会给出警告，加入的数据类型被转化为Object类型，外部访问该类存储的元素时，需要做类型的强制转换。

使用泛型的示例代码如下：

package com.milihua.generic;
public class GenericDemo {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 里面的var类型为String类型
        Point<String> p = new Point<String>() ;
        //设置一个点
        p.setVar("(300,200)") ;       
        //输出这个点
        System.out.println(p.getVar()) ;
    }
}

程序在实例化Point类时，传入字符串类型，并调用Point类的setVar方法设置Point的数据，调用Point类的getVar方法获取数据，无需做数据类型的强制转换。

文章小结

泛型不仅可以将运行时异常转换成编译器错误，减少运行时异常的数量。而且可以解决模板编程的问题。例如文中的Point类，不仅可以存储字符串，也可以存储浮点数等数据类型，可以适应不同的编程需求，而无需变更代码。

思考与练习

1、Java中的泛型是什么 ? 使用泛型的好处是什么?

2、编写一个泛型类，让它能接受泛型参数并返回泛型类型。

3、可以把List<String>传递给一个接受List<Object>参数的方法吗？为什么？