Java范型浅析

转载 2007年09月19日 10:56:00

        从jdk1.5开始,Java中开始支持范型了。范型是一个很有用的编程工具,给我们带来了极大的灵活性。在看了《java核心编程》之后,我小有收获,写出来与大家分享。

        所谓范型,我的感觉就是,不用考虑对象的具体类型,就可以对对象进行一定的操作,对任何对象都能进行同样的操作。这就是灵活性之所在。但是,正是因为没有考虑对象的具体类型,因此一般情况下不可以使用对象自带的接口函数,因为不同的对象所携带的接口函数不一样,你使用了对象A的接口函数,万一别人将一个对象B传给范型,那么程序就会出现错误,这就是范型的局限性。

     所以说,范型的最佳用途,就是用于实现容器类,实现一个通用的容器。该容器可以存储对象,也可以取出对象,而不用考虑对象的具体类型。因此,在学习范型的时候,一定要了解这一点,你不能指望范型是万能的,要充分考虑到范型的局限性。下面我们来探讨一下范型的原理以及高级应用。首先给出一个范型类:

public class Pair<T> 
...
   public Pair() ...{ first = null; second = null; } 
   public Pair(T first, T second) ...this.first = first;  this.second = second; } 
 
   public T getFirst() ...return first; } 
   public T getSecond() ...return second; } 
 
   public void setFirst(T newValue) ...{ first = newValue; } 
   public void setSecond(T newValue) ...{ second = newValue; } 
 
   private T first; 
   private T second; 
}
 


        我们看到,上述Pair类是一个容器类(我会多次强调,范型天生就是为了容器类的方便实现),容纳了2个数据,但这2个数据类型是不确定的,用范型T来表示。关于范型类如何使用,那是最基本的内容,在此就不讨论了。
        下面我们来讨论一下Java中范型类的实现原理。在java中,范型是在编译器中实现的,而不是在虚拟机中实现的,虚拟机对范型一无所知。因此,编译器一定要把范型类修改为普通类,才能够在虚拟机中执行。在java中,这种技术称之为“擦除”,也就是用Object类型替换范型。上述代码经过擦除后就变成如下形式:
Comparable来替换所有范型),当需要用到其他约束中定义的方法的时候,通过插入强制转化代码来实现。在此就不给出具体的例子了。
        下面我们来看看最后一个知识点,定义一个函数,该函数接受一个范型类作为参数。首先让我们来看一个最简单的情况,参数是一个实例化的范型类:
l.get(0)是合法的,因为参数是整型而不是范型;l.add(x)就不合法,因为add函数的参数是范型。但是定义一个范型方法还是有一定灵活性的,如果传入的数据也是范型,编译器还是认可的,因为范型对范型,类型安全是可以保证的。
        从上述代码可以看出,定义一个范型方法要比Wildcard稍微灵活一些,可以往链表中添加T类型的对象,而Wildcard中是不允许往链表中添加任何类型的对象的。那么我们还要Wildcard干什么呢?
Wildcard还是有他存在的意义的,那就是,Wildcard支持另外一个关键字super,而范型方法不支持super关键字。换句话说,如果你要实现这样的功能:“传入的参数应该是指定类的父类”,范型方法就无能为力了,只能依靠Wildcard来实现。代码如下: l.add((Integer)x); ,编译器不就不报错了吗?确实,经过强制转化后,编译器确实没意见了。不过这种强制转化有可能带来运行时错误。因为你传入的实参,其元素类型是Integer的父类,比如是Number。那么,存储在该链表中的第一个数据,很有可能是Double或其他类型的,这是合法的。那么你取出的第一个元素x也会是Double类型。那么你把一个Double类型强制转化为Integer类型,显然是一个运行时错误。
        难道“把取出的元素再插入到链表中”这样一个功能就实现不了吗?当然可以,不过不能直接实现,要借助范型函数的帮忙,因为在范型函数中,刚刚取出的元素再存回去是不成问题的。定义这样一个范型函数,我们称之为帮助函数。代码如下:

public class Pair 
...
   public Pair(Object first, Object second) 
   ...
      this.first = first; 
      this.second = second; 
   }
 
 
   public Object getFirst() ...return first; } 
   public Object getSecond() ...return second; } 
 
   public void setFirst(Object newValue) ...{ first = newValue; } 
   public void setSecond(Object newValue) ...{ second = newValue; } 
 
   private Object first; 
   private Object second; 
}
 


        大家可以看到,这是一个普通类,所有的范型都被替换为Object类型,他被称之为原生类。每当你用一个具体类去实例化该范型时,编译器都会在原生类的基础上,通过强制约束在需要的地方添加强制转换代码来满足需求,但是不会生成更多的具体的类(这一点和c++完全不同)。我们来举例说明这一点:

Pair<Employee>  buddies  =  new  Pair<Employee>(); 

//在上述原生代码中,此处参数类型是Object,理论上可以接纳各种类型,但编译器通过强制约束
//你只能在此使用Employee(及子类)类型的参数,其他类型编译器一律报错
buddies.setFirst(new Employee("张三")); 

//在上述原生代码中,getFirst()的返回值是一个Object类型,是不可以直接赋给类型为Employee的buddy的
//但编译器在此做了手脚,添加了强制转化代码,实际代码应该是Employee buddy = (Employee)buddies.getFirst();
//这样就合法了。但编译器做过手脚的代码你是看不到的,他是以字节码的形式完成的。
Employee buddy = buddies.getFirst();


        下面我们再来考察一个更复杂的情况,如果我们的Pair类要保证第二个属性一定要大于第一个属性,该如何做?这就涉及到两个属性的比较,但是这2个属性类型未知,可以比较吗?我们前面也讲过,一般情况下不要涉及类型的具体信息。但是现在要比较2个属性,不得不涉及类型的具体信息了。Java还是考虑到了这一点,那就是,范型类可以继承自某一个父类,或者实现某个接口,或者同时继承父类并且实现接口。这样的话,就可以对类型调用父类或接口中定义的方法了。代码如下:

public class Pair<T extends Comparable> 
...
   public boolean setSecond(T newValue) ...
   boolean flag = false;
   If(newValue.compareTo(first)>0) ...{
     second = newValue;
     flag = true;
   }

   return flag;
}
 
 
   private T first; 
   private T second; 
}
 


        我们看到,上面的范型T被我们添加了一个约束条件,那就是他必须实现Comparable接口,这样的话,我们就可以对范型T使用接口中定义的方法了,也就可以实现2个元素大小的比较。有人可能要问了,实现一个接口不是用implements吗?上面怎么用extends呢??为了简化范型的设计,无论是继承类还是实现接口,一律使用extends关键字。这是规定,没办法,记住就行了。若同时添加多个约束,各个约束之间用“&”分隔,比如:public class Pair<T extends Comparable & Serializable>。那么编译器是如何处理这种情况呢?前面讲过,范型类最终都会被转化为原生类。在前面没有添加约束的时候,编译器将范型通通替换为Object;而增加了约束之后,通通用第一个约束来替换范型(上面的代码就会用

    public static void test(ArrayList<Number> l) ...{
        l.add(new Integer(2));
    }


        上述代码中,形参list的元素被实例化为Number类型。在使用该函数的时候我们能不能传入一个元素为Integer的list呢?看看下面代码合法吗?

    ArrayList<Integer> l = new ArrayList<Integer>();
    test(l);  //此处编译器会报错!!


        答案上面已经给出了:不行!对于这种形参,实参的类型必须和他完全一致,即也应该是一个元素为Number的list才可以,其他的实参一律不行。这是为什么呢?Integer不是Number的子类吗?子类的对象传递给父类的引用,不可以吗?这里我们就要注意了,Integer确实是Number的子类,但是,ArrayList<Integer>并不是ArrayList<Number>的子类,二者之间没有任何的继承关系!!因此这样传递参数是不允许的。如果允许的话,会出现什么问题吗?当然会,我们对test函数重新定义一下:

    public static void test(ArrayList<Number> l) ...{
        l.add(new Float(2));
    }


        大家可以看到,在函数内部,我们把Float类型的元素插入到链表中。因为链表是Number类型,这条语句没问题。但是,如果实参是一个Integer类型的链表,他能存储Float类型的数据吗??显然不能,这样就会造成运行时错误。于是,编译器干脆就不允许进行这样的传递。
        通过分析我们看到,出错的可能性只有一个:在向容器类添加内容的时候可能造成类型不匹配。那么有些人可能会有这种要求:“我保证一定不对容器添加内容,我非常希望能够将一个Integer类(Number类的子类)组成的链表传递进来”。Sun的那帮大牛们当然会考虑到这种诉求,这样的功能是可以实现的,并且还有两种方式呢,看下面代码:

//     1.在定义方法的时候使用Wildcard(也就是下述代码中的问号)。
    public static void test1(ArrayList<? extends Number> l) ...{
        Integer n = new Integer(45);
        Number x = l.get(0); //从链表中取数据是允许的
        l.add(n);  //错误!!往链表里面插入数据是被编译器严格禁止的!!
    }


//     2.定义一个范型方法。代码如下:
    public static <T extends Number> void test2(ArrayList<T> l) ...{
        Number n = l.get(0);
        T d = l.get(0);
        l.add(d);  //与上面的方法相比,插入一个范型数据是被允许的,相对灵活一些
        l.add(n);  //错误!!只可以插入范型数据,绝不可插入具体类型数据。
    }


        按照上述代码的写法,只要我们对形参添加了一定的约束条件,那么我们在传递实参的时候,对实参的严格约束就会降低一些。上述代码都指定了一个类Number,并用了extends关键字,因此,在传递实参的时候,凡是从Number继承的类组成的链表,均可以传递进去。但上面代码的注释中也说的很清楚,为了不出现运行时错误,编译器会对你调用的方法做严格的限制:凡是参数为范型的方法,一律不需调用!!

    public static void test5(ArrayList<? super Integer> l) ...{
        Integer n = new Integer(45);
        l.add(n);  //与上面使用extends关键字相反,往链表里面插入指定类型的数据是被允许的。
        Object x = l.get(0); //从链表里取出一个数据仍然是被允许的,不过要赋值给Object对象。
        l.add(x);   //错误!!将刚刚取出的数据再次插入链表是不被允许的。
    }

        这种实现方式的特点我们前面已经说过了,就是对实参的限制更改为:必须是指定类型的父类。这里我们指定了Integer类,那么实参链表的元素类型,必须是Number类及其父类。下面我们重点讨论一下上述代码的第四条语句,为什么将刚刚取出的数据再次插入链表不被允许??道理很简单,刚刚取出的数据被保存在一个Object类型的引用中,而链表的add方法只能接受指定类型Integer及其子类,类型不匹配当然不行。有些人可能立刻会说,我将他强制转化为Integer类(即

    //帮助函数
    public static <T>void helperTest5(ArrayList<T> l, int index) ...{
        T temp = l.get(index);
        l.add(temp);
    }

    
    //主功能函数
    public static void test5(ArrayList<? super Integer> l) ...{
        Integer n = new Integer(45);
        l.add(n);  
        helperTest5(l, 0);   //通过帮助类,将指定的元素取出后再插回去。
    }


        上述两个函数结合的原理就是:利用Wildcard的super关键字来限制参数的类型(范型函数不支持super,要是支持的话就不用这么麻烦了),然后通过范型函数来完成取出数据的再存储。
        以上就是我学习范型的所有心得。下面再把《Java核心编程》中列出的使用范型时的注意事项列出来(各种操作被禁止的原因就不具体说明了),供大家参考:

//1、不可以用一个本地类型(如int   float)来替换范型
//2、运行时类型检查,不同类型的范型类是等价的(Pair<String>与Pair<Employee>是属于同一个类型Pair),
//     这一点要特别注意,即如果a instanceof Pair<String>==true的话,并不代表a.getFirst()的返回值是一个String类型
//3、范型类不可以继承Exception类,即范型类不可以作为异常被抛出
//4、不可以定义范型数组
//5、不可以用范型构造对象,即first = new T(); 是错误的
//6、在static方法中不可以使用范型,范型变量也不可以用static关键字来修饰
//7、不要在范型类中定义equals(T x)这类方法,因为Object类中也有equals方法,当范型类被擦除后,这两个方法会冲突
//8、根据同一个范型类衍生出来的多个类之间没有任何关系,不可以互相赋值
//     即Pair<Number> p1;  Pair<Integer> p2;   p1=p2;  这种赋值是错误的。
//9、若某个范型类还有同名的非范型类,不要混合使用,坚持使用范型类
//     Pair<Manager> managerBuddies = new Pair<Manager>(ceo, cfo);
//     Pair rawBuddies = managerBuddies;  这里编译器不会报错,但存在着严重的运行时错误隐患

Java范型浅析

从jdk1.5开始,Java中开始支持范型了。范型是一个很有用的编程工具,给我们带来了极大的灵活性。在看了《java核心编程》之后,我小有收获,写出来与大家分享。         所谓范型,我的感觉...
  • tjpuzm
  • tjpuzm
  • 2013年03月19日 10:12
  • 275

C++ 宏、范型和RTTI 浅析

RTTI(Run-Time Type Identification)是面向对象程序设计中一种重要的技术。现行的C++标准对RTTI已经有了明确的支持。不过在某些情况下出于特殊的开发需要,我们需要自己编...

Java自定义范型的应用技巧

我们在JAVA中 处处都用到了 范型 ,JAVA中的范型是从C++模板继承来的,不过  JAVA的 范型的功能 远远没有 C++那么强大 。 我们知道在C++中 模板可以很方便的代替任意类型的数据 ...

java范型的应用

前一段在壹平台面试的时候,有个人问道java范型的应用,我突然意识到,我一直用范型 ,用的最多时候就是集合 List userList = new ArrayList();这样的,具体的为什么要这样用...

java范型类型擦除

一. 概述 在上一篇范型博客中,主要讲解了范型的基本使用和设计,在本篇博客中主要讲解使用范型带来的问题和解决方法。 在使用java范型时,我们通常会遇到诸多问题,例如不能使用T.class,...

Java范型

1.java泛型及就是在jdk1.5之后出现的一个新的安全机制 我们发现在集合框架中我们可以放入任何的元素,然而这样做并没有任何意义,绝大多时候我们是默认我们 知道这个容器需要存放什么样的...

java中List范型使用总结

欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来,用它写博客,将会带来全新的体验哦: Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和...

为什么Java不支持创建范型数组?

最近看到BlogJava上有人在讨论为什么Java范型不支持数组http://www.blogjava.net/myqiao/archive/2005/08/08/9580.html   我想这个问题...

基于范型的java验证框架

经历了很多项目的人,会发现几乎没有哪个项目不需要验证的。在经历过多个项目之后,有感于项目中使用最多的验证方式,这里写了一个基于java反射机制的验证框架。该框架适用于对javaBean中的属性通过ja...

Java 数组转型和范型

今天写代码遇到一个奇怪的问题,代码结构如下: [java] view plain copy  print? ArrayList list = new ArrayList();   S...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java范型浅析
举报原因:
原因补充:

(最多只允许输入30个字)