黑马程序员——JAVA基础---使用泛型

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

在介绍泛型之前，先来看一个例子。
【例】 在项目中创建Test类，该类中使基本类型向上转型为Object类型。

public class Test {
    private Object b;                               //定义Object类型成员变量
    public Object getB() {                  //设置相应getXXX()方法
        return b;
    }
    public void setB(Object b) {                    //设置相应setXXX()方法
        this.b = b;
    }
    public static void main(String[] args) {
        Test t=new Test();
        t.setB(new Boolean(true));              //向上转型操作
        System.out.println(t.getB())
        t.setB(new Float(12.3));
        Float f=(Float)(t.getB());              //向下转型操作
        System.out.println(f);
    }
}

运行本实例，运行结果如图所示。

 图  使基本类型向上转型为Object类型
 在本实例中，Test类中定义了私有的成员变量b，它的类型为Object类型，同时相应地为其定义了setXXX()与getXXX()方法。在类主方法中，将new Boolean(true)对象作为setB()方法的参数，由于setB()方法的参数类型为Object，这样就实现了“向上转型”的操作，同时，在调用getB()方法时，将getB()方法返回的Object对象以相应的类型返回，这个就是“向下转型”操作。问题通常就会出现在这里，我们知道“向上转型”是安全的，而“向下转型”时，就容易出现问题，例如：

t.setB(new Float(12.3));
Integer f=(Integer)(t.getB());
System.out.println(f);
在上述代码中，并不存在语法错误，所以可以被编译器所接受，但在执行时会出现ClassCast- Exception异常。从上述代码可以看出，“向下转型”操作通常会出现问题，泛型机制能有效地解决了这一问题。

一 定义泛型类

Object类为最上层的父类，很多程序员为了使程序更为通用，设计程序时通常使传入的值与返回的值都以Object类型为主。当需要使用这些实例时，必须正确地将该实例转换为原来的类型，否则在运行时将会发生ClassCastException异常。

下面介绍泛型机制，其语法如下：
类名
其中，T代表一个类型的名称。
将前面的例子进行改写，在定义类时使用泛型的形式，关键代码如下所示。
在项目中创建OverClass类，该类定义了泛型类。

public class OverClass<T>{                      //定义泛型类
    private T over;                                 //定义泛型成员变量
    public T getOver() {                                //设置getXXX()方法
        return over;
    public void setOver(T over) {                   //设置setXXX()方法
        this.over = over;
    public static void main(String[] args) {
        //实例化一个Boolean型的对象
        OverClass<Boolean> over1=new OverClass<Boolean>();
        //实例化一个Float型的对象
        OverClass<Float> over2=new OverClass<Float>();
        over1.setOver(true);                            //不需要进行类型转换
        over2.setOver(12.3f);   
        Boolean b=over1.getOver();              //不需要进行类型转换
        Float f=over2.getOver();
        System.out.println(b);
        System.out.println(f);
    }
}

运行上述代码，运行结果与图所示的运行结果一致。在例中定义类时，在类名后添加了一个“<T>”，便是使用了泛型机制，可以将OverClass类称为泛型类，同时返回和接受的参数使用T这个类型。最后，在主方法中可以使用Over<Boolean>形式返回一个Boolean型的对象，使用OverClass<Float>形式返回一个Float型的对象，使这两个对象分别调用setOver()方法就不需要进行显式“向上转型”操作，setOver()方法直接接受相应类型的参数，而调用getOver()方法时，不需要进行“向下转型”操作，而直接将getOver()方法返回的值赋予相应的类型变量即可。
从例中可以看出，使用泛型定义的类在声明该类对象时，可以根据不同的需求指定<T>真正的类型，而在使用类中的方法传递或返回数据类型时，将不再需要进行类型转换操作，而是使用在声明泛型类对象时<>符号中设置的数据类型。
使用泛型这种形式将不会发生ClassCastException异常，因为在编译器中就可以检查类型匹配是否正确。

在项目中定义泛型类。

OverClass<Float> over2=new OverClass<Float>();
over2.setOver(12.3f);
//Integer i=over2.getOver();                //不能将Boolean型的值赋予Integer变量

在上例中，由于over2对象在实例化时已经指定类型为Float，而最后一条语句却将该对象获取的Float类型值赋予Integer类型，所以编译器会报错。这种问题如果使用“向下转型”操作，就会在运行上述代码时才会发生问题。

说明：
在定义泛型类时，一般将类型名称使用T来表达，而容器的元素使用E来表达，具体的设置读者可以参看API。

二 泛型的常规用法

1．定义泛型类时声明多个类型
在定义泛型类时，可以声明多个类型，语法如下：
MutiOverClass

public class ArrayClass <T>{
    private T[] array;          //定义泛型数组
    public void SetT(T[] array){    //设置SetXXX()方法为成员数组赋值
        this.array=array;
    }
    public T[] getT(){              //获取成员数组
        return array;
    }
    public static void main(String[] args) {
        ArrayClass<String> a=new ArrayClass<String>();
        String[] array={"成员1","成员2","成员3","成员4","成员5"};
        a.SetT(array);                      //调用SetT()方法
        for(int i=0;i<a.getT().length;i++){
    System.out.println(a.getT()[i]);//调用getT()方法返回数组中的值
        }
    }
}

在Eclipse中运行本实例，运行结果如图所示。

图 定义泛型类时声明数组类型
由上可见，可以在使用泛型机制时声明一个数组，但是不可以使用泛型来建立数组的实例，如下面的代码就是错误的：

public class ArrayClass <T>{
    //private T[] array=new T[10];      //不能使用泛型来建立数组的实例
    ...
}

3．集合类声明容器的元素
可以使用K和V两个字符代表容器中的键值和与键值相对应的具体值。

【例】 在项目中创建MutiOverClass类，在该类中使用了集合类声明容器的元素。

public class MutiOverClass <K,V>{
    public Map<K,V> m=new HashMap<K,V>();   //定义一个集合HashMap实例
    public void put(K k,V v){//设置put()方法，将具体值与对应具体值的键值放入集合中
        m.put(k, v);
    }
    public V get(K k){                  //根据键值获取键值
        return m.get(k);
    }
    public static void main(String[] args) {
        //实例化泛型类对象
        MutiOverClass<Integer,String> mu=new  MutiOverClass<Integer, 
String>();
        for(int i=0;i<5;i++){
            //根据集合的长度循环将键值与具体值放入集合中
            mu.put(i,"我是集合成员"+i);
        }
        for(int i=0;i<mu.m.size();i++){
            //调用get()方法获取集合中的值
            System.out.println(mu.get(i));
        }
    }
}

在Eclipse中运行本实例，运行结果如图所示。

图 集合类声明容器的元素
其实在例中定义的泛型类MutiOverClass类属于多此一举，因为在Java中这些集合框架已经都被泛型化了，可以在主方法中直接使用public Map

public class AnyClass{
    public static void main(String[] args) {
        //定义ArrayList容器，设置容器内的值类型为Integer
        ArrayList<Integer> a=new ArrayList<Integer>();
        a.add(1);                                   //为容器添加新值
        for(int i=0;i<a.size();i++){
            //根据容器的长度循环显示容器内的值
            System.out.println(“获取ArrayList容器的值：”+a.get(i));
        //定义HashMap容器，设置该容器的键值与具体内容的类型分别为Integer与String型
        Map<Integer,String> m=new HashMap<Integer, String>();
        for(int i=0;i<5;i++){
            m.put(i,"成员"+i);                        //为容器填充键值与内容
        }
        for(int i=0;i<m.size();i++){
            System.out.println(“获取Map容器的值”+m.get(i));
                                                        //根据键值获取容器的内容
        //定义Vector容器，使容器中的内容为String型
        Vector<String> v=new Vector<String>();
        for(int i=0;i<5;i++){
            v.addElement(“成员”+i);       //为Vector容器添加内容
        for(int i=0;i<v.size();i++){
            //显示容器中的内容
            System.out.println("获取Vector容器的值"+v.get(i));

public class AnyClass{
public static void main(String[] args) {
//定义ArrayList容器，设置容器内的值类型为Integer
ArrayList a=new ArrayList();
a.add(1); //为容器添加新值
for(int i=0;i

三 泛型的高级用法

泛型的高级用法包括限制泛型可用类型、使用类型通配符等。
1．限制泛型可用类型
默认可以使用任何类型来实例化一个泛型类对象，但是Java中也对泛型类实例的类型做了限制，语法如下：
class 类名称
其中，anyClass是指某个接口或类。
使用泛型限制后，泛型类的类型必须实现或继承了anyClass这个接口或类。无论anyClass是接口或类，在进行泛型限制时，都必须使用extends关键字。
【例】 在项目中创建LimitClass类，在该类中限制泛型类型。

public class LimitClass<T extends List>{            //限制泛型的类型
    public static void main(String[] args) {
        LimitClass<ArrayList> l1=new LimitClass<ArrayList>();   
            //可以实例子化实现List接口的类
        LimitClass<LinkedList> l2=new LimitClass<LinkedList>();
        //这句是错误的，因为HashMap没有实现List()接口
        //LimitClass<HashMap> l3=new LimitClass<HashMap>();
    }
}

在例中，将泛型做了限制，设置泛型类型必须实现List接口，例如，ArrayList和LinkedList都实现了List接口，而HashMap没有实现List接口，所以在这里不能实例化HashMap类型的泛型对象。
当没有使用extends关键字限制泛型类型时，默认Object类下的所有子类都可以实例化泛型类对象。如图所示的两个语句是等价的。

图 等价的两个泛型类

2．使用类型通配符
在泛型机制中，提供了类型通配符，其主要作用是在创建一个泛型类对象时，限制这个泛型类的类型实现或继承某个接口或类的子类。要声明这样一个对象，可以使用“？”通配符来表示，同时，依然需要使用extends关键字来对泛型加以限制。
使用泛型类型通配符的语法如下：
泛型类名称

List<String> l1=new ArrayList<String>();            //实例化一个ArrayList对象
l1.add("成员");                           //在集合中添加内容
List<?> l2=l1;                          //使用通配符
List<?> l3=new LinkedList<Integer>();
System.out.println(l2.get(0));                  //获取集合中第一个值

在例中，List<?>类型的对象可以接受String类型的ArrayList集合，也可以接受Integer类型的LinkedList集合。也许有的读者会有疑问，List<?> l2=l1语句与List l2=l1存在何种本质区别？这里需要注意，使用通配符声明的名称实例化的对象不能对其加入新的信息，只能获取或删除，例如：

l1.set(0, "成员改变");              //没有使用通配符的对象调用set()方法，
//l2.set(0, "成员改变");                //使用通配符的对象调用set()方法，不能被调用
//l3.set(0, 1);
l2.get(0);                          //可以使用l2的实例获取集合中的值
l2.remove(0);                       //根据键值删除集合中的值

从上述代码中可以看到，由于对象l1是没有使用A<?>这种形式初始化出来的对象，所以它可以调用set()方法改变集合中的值，但l2与l3则是通过使用通配符的方式创建出来的，所以不能改变集合中的值。

技巧：
泛型类型限制除了可以向下限制之外，还可以向上限制，只要在定义时使用super关键字。例如，A

public class ExtendClass<T1>{
    //...
}
class SubClass<T1,T2,T3> extends ExtendClass<T1>{
    //...
}

如果在SubClass类继承ExtendClass类时保留父类的泛型类型，需要在继承时指明，如果没有指明，直接使用extends ExtendsClass语句进行继承操作，则SubClass类中的T1、T2、T3都会自动变为Object，一般情况下，都将父类的泛型类型保留。

定义的泛型接口也可以被实现。
在项目中创建一个类文件，在该类中实现泛型接口。

interface i<T1>{
    //...
}
class SubClass2<T1,T2,T3> implements i<T1>{
    //...
}

四 泛型总结

泛型的使用方法如下：
泛型的类型参数只能是类类型，不可以是简单类型，如A这种泛型定义就是错误的。
泛型的类型个数可以是多个。
可以使用extends关键字限制泛型的类型。
可以使用通配符限制泛型的类型。