Java5新特性-泛型的使用总结（一）

Java5的泛型的语法，已经有很多帖子讲了，这里依据我的一些个人理解做一次总结，一方面是为了将我近一段时间对泛型的学习落实到纸面，毕竟有很多想 法，如果只是存在于脑子里，过一段时间也就淡忘了，总要留下点文字便于以后回顾；另一方面，也希望拿出点东西来与大家交流分享，这样才能不断的得到提高。

泛型是什么

简单的来说，泛型可以认为是类型参数化的技术。相对于类型的参数化，在传统的java代码中，我们可以理解为所有的参数都是值的参数化，例如以下代码：

 1  package  org.dbstar.generic;
 2 
 3  public  class  ValueHolder {
 4       private  String value;
 5 
 6       public  ValueHolder(String value) {
 7           this .value  =  value;
 8      }
 9 
10       public  String getValue() {
11           return  value;
12      }
13 
14       public  void  setValue(String value) {
15           this .value  =  value;
16      }
17  }

其中的成员变量、构造函数参数和方法参数，都可以认为是值的参数化的体现。但是，不管值如何变化，值的类型只能局限于String及其子类，如果我们想让 ValueHolder同时也能持有一个Integer类型的值，那么在传统的Java代码中，只能将成员变量的类型定义为Object，如下：

 1  package  org.dbstar.generic;
 2 
 3  public  class  ValueHolder {
 4       private  Object value;
 5 
 6       public  ValueHolder(Object value) {
 7           this .value  =  value;
 8      }
 9 
10       public  Object getValue() {
11           return  value;
12      }
13 
14       public  void  setValue(Object value) {
15           this .value  =  value;
16      }
17  }

使用Object版的ValueHolder的代码看起来会像这样：

1       public  static  void  main(String[] args) {
2          ValueHolder vhi  =  new  ValueHolder( new  Integer( 1 ));
3          ValueHolder vhs  =  new  ValueHolder( " abc " );
4          ValueHolder vho  =  new  ValueHolder( new  Object());
5          System.out.println( " ValueHolder of Integer= "  +  vhi.getValue());
6          System.out.println( " ValueHolder of String= "  +  vhs.getValue());
7          System.out.println( " ValueHolder of Object= "  +  vho.getValue());
8      }

输出结果为：

1  ValueHolder of Integer = 1
2  ValueHolder of String = abc
3  ValueHolder of Object = java.lang.Object@757aef

幸运的是，Java5给我们提供了一个将value的类型也作为一个参数来设置的方法，那就是泛型，下面是将value的类型也参数化后的 ValueHolder实现：

 1  package  org.dbstar.generic;
 2 
 3  public  class  ValueHolder < E >  {
 4       private  E value;
 5 
 6       public  ValueHolder(E value) {
 7           this .value  =  value;
 8      }
 9 
10       public  E getValue() {
11           return  value;
12      }
13 
14       public  void  setValue(E value) {
15           this .value  =  value;
16      }
17  }

其中，value就是值的参数化，value的类型现在定义为E，<E>就是类型的参数化。使用ValueHolder的代码也相应发生了变 化：

1          ValueHolder < Integer >  vhi  =  new  ValueHolder < Integer > ( new  Integer( 1 ));
2          ValueHolder < String >  vhs  =  new  ValueHolder < String > ( " abc " );
3          ValueHolder < Object >  vho  =  new  ValueHolder < Object > ( new  Object());
4          System.out.println( " ValueHolder of Integer= "  +  vhi.getValue().intValue());
5          System.out.println( " ValueHolder of String= "  +  vhs.getValue().substring( 1 ));
6          System.out.println( " ValueHolder of Object= "  +  vho.getValue());

根据ValueHolder类型定义的不同，类型参数<E>在不同场合代表了不同的实际类型。

泛型的赋值

与值参数的赋值不同的是，类型参数的赋值有其特殊性，下面来逐一说明：
A。同类型赋值：

1          ValueHolder < Integer >  vhi  =  new  ValueHolder < Integer > ( new  Integer( 1 ));
2          ValueHolder < Integer >  vhi2  =  vhi;
3          vhi2.setValue( new  Integer( 2 ));
4          System.out.println( " ValueHolder of Integer2= "  +  vhi2.getValue().intValue());

这种赋值后的变量，与源变量具有完全一致的操作，包括获取泛型变量和在方法参数中设置泛型变量。
B。超类型赋值：

1          ValueHolder < Integer >  vhi  =  new  ValueHolder < Integer > ( new  Integer( 1 ));
2          ValueHolder < Number >  vhi3  =  vhi; // 实际上，这是不允许的，会导致编译错误
3          ValueHolder <?  extends  Number >  vhi2  =  vhi; // 必须要这样写
4          System.out.println( " ValueHolder of Integer2= "  +  vhi2.getValue().intValue());
5          vhi2.setValue( new  Integer( 2 )); // 超类型赋值后，操作受到限制，会导致编译错误
6          vhi2.setValue( null ); // 只有设置null值才是合法的，其他值一概不允许设置

这种赋值后的变量，能调用返回值为泛型变量的方法，但是只能使用新泛型变量类型的方法，而不能再使用原有泛型变量类型上的方法，这样说有点绕，举例来说， 上面的vhi2就只能使用Number类型上定义的方法，而无法再使用原先在Integer类型上定义的方法了。
可赋值的超类型可以是原类型的任何超类型或者接口，这些赋值都是类型安全的，不会引发任何编译时警告。例如：

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> --> 1          ValueHolder <?   extends  Number >  vhn  =  vhi; // 超类
2          ValueHolder <?   extends  Object >  vho2  =  vhi; // 超类
3          ValueHolder <?   extends  Comparable >  vhc  =  vhi; // 接口

赋值后的带?的泛型，还能继续赋值给超类，例如：

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> --> 1          ValueHolder <?   extends  Number >  vhn  =  vhi;
2          ValueHolder <?   extends  Object >  vho3  =  vhn;

ValueHolder<?>等效于ValueHolder<? extends Object>，因为Object是所有类的超类。
C。子类型赋值：

1          ValueHolder <?  extends  Number >  vhi2  =  vhi; // 必须要这样写
2          @SuppressWarnings( " unchecked " )
3          ValueHolder < Integer >  vhi3  =  (ValueHolder < Integer > ) vhi2;

和值参数的赋值一样，超类型的泛型变量往子类型的泛型变量赋值，需要强制转换，转换后的vhi3与vhi具有完全一致的操作。但是，需要注意的一点是，这 种转换会导致一个unchecked的编译时警告，而且，若无法完成转换，会导致一个运行时的ClassCastException异常，例如：

1          @SuppressWarnings( " unchecked " )
2          ValueHolder < Double >  vhi3  =  (ValueHolder < Double > ) vhi2; // 这里不会抛出异常
3          vhi3.setValue( new  Double( 12.5 ));
4          System.out.println( " ValueHolder of Double= "  +  vhi3.getValue().doubleValue());
5          System.out.println( " ValueHolder of Integer= "  +  vhi.getValue().intValue()); // 会在这里抛出ClassCastException

上例中，vhi2将Integer类型转换成了超类型Number，而vhi3又将Number强类型转换成了Double，这也是允许的，不会引发编译 时错误或者运行时错误。下面甚至还可以给vhi3设置一个Double的值，值得注意的是，vhi3其实就是vhi，我们给一个Integer的变量设置 了一个Double的值，却没有引发任何异常，还真是诡异的很。随后，我们在调用vhi.getValue().intValue()时，才终于引发了 ClassCastException。由此可见，这种强类型转换有时候会使错误变得非常隐晦难于发现，我们应该尽量避免这种转换的使用。
D。赋值给传统代码(row type赋值)：

1          @SuppressWarnings( " unchecked " )
2          ValueHolder vh  =  vhi;
3          vh.setValue( new  Integer( 3 ));

不指定类型参数的泛型类，称之为row type，这是Java5泛型为了与老版本的代码兼容而选择的一种处理方式。Row type的泛型类中，所有的类型参数都被当做Object来处理，也就是说，ValueHolder可以当做 ValueHolder<Object>来处理，但是与ValueHolder<Object>又有所不同，因为 ValueHolder<Integer>是不能被转换为ValueHolder<Object>的，而能转换的ValueHolder<? extends Object>又不能调用setValue方法(当然可以设置null值，而其他非null值不能设置)。值得注意的是，转换到传统代码，以及使用 传统代码调用有泛型参数的方法，会引起一个unchecked的编译时警告。
E。传统代码(row type)赋值给泛型
与第三点：子类型赋值类似，可以将传统代码看做是ValueHolder<? extends Object>，同样需要强类型转换，以及存在类型安全问题。