舞影凌风

转自：http://www.2cto.com/kf/201208/146652.html

“JDK1.5”的一个重要主题就是通过新增一些特性来简化开发，这些特性包括泛型，for-each　循环，自动装包/拆包，枚举，可变参数,　静态导入　。使用这些特性有助于我们编写更加清晰，精悍，安全的代码。

一． 首先简单介绍一下各种特性及其使用

1.泛型(Generic)
C++通过模板技术可以指定集合的元素类型，而Java在1.5之前一直没有相对应的功能。一个集合可以放任何类型的对象，相应地从集合里面拿对象的时候我们也不得不对他们进行强制得类型转换。猛虎引入了泛型，它允许指定集合里元素的类型，这样你可以得到强类型在编译时刻进行类型检查的好处。

“JDK1.5”的一个重要主题就是通过新增一些特性来简化开发，这些特性包括泛型，for-each　循环，自动装包/拆包，枚举，可变参数,　静态导入　。使用这些特性有助于我们编写更加清晰，精悍，安全的代码。

一． 首先简单介绍一下各种特性及其使用

1.泛型(Generic)
C++通过模板技术可以指定集合的元素类型，而Java在1.5之前一直没有相对应的功能。一个集合可以放任何类型的对象，相应地从集合里面拿对象的时候我们也不得不对他们进行强制得类型转换。猛虎引入了泛型，它允许指定集合里元素的类型，这样你可以得到强类型在编译时刻进行类型检查的好处。

1 Collection c = new ArrayList();
2 c.add(new Date());

编译器会给出一个错误：

add(java.lang.String) in java.util.Collection cannot be applied to (java.util.Date)

2.For-Each循环
For-Each循环得加入简化了集合的遍历。假设我们要遍历一个集合对其中的元素进行一些处理。典型的代码为：

[java]
void processAll(Collection c){ 
 for(Iterator i=c.iterator(); i.hasNext();){ 
    MyClass myObject = (MyClass)i.next(); 
    myObject.process(); 
 } 
  

 void processAll(Collection c){
  for(Iterator i=c.iterator(); i.hasNext();){
     MyClass myObject = (MyClass)i.next();
     myObject.process();
  }
}

使用For-Each循环，我们可以把代码改写成：

[java]
 void processAll(Collection c){ 
  for (MyClass myObject :c){ 
      myObject.process(); 
  } 
}  

 void processAll(Collection c){
  for (MyClass myObject :c){
      myObject.process();
  }
}

这段代码要比上面清晰许多，并且避免了强制类型转换。

3.自动装包/拆包(Autoboxing/unboxing)
自动装包/拆包大大方便了基本类型数据和它们包装类地使用。
自动装包：基本类型自动转为包装类.(int >> Integer)
自动拆包：包装类自动转为基本类型.(Integer >> int)

在JDK1.5之前，我们总是对集合不能存放基本类型而耿耿于怀，现在自动转换机制解决了我们的问题。

[java]
int a = 3; 
Collection c = new ArrayList(); 
c.add(a);//自动转换成Integer.  
Integer b = new Integer(2); 
c.add(b + 2);  

 int a = 3;
 Collection c = new ArrayList();
 c.add(a);//自动转换成Integer.
 Integer b = new Integer(2);
 c.add(b + 2);

这里Integer先自动转换为int进行加法运算，然后int再次转换为Integer.

4.枚举(Enums)
JDK1.5加入了一个全新类型的“类”－枚举类型。为此JDK1.5引入了一个新关键字enmu.　我们可以这样来定义一个枚举类型。

[java]
public enum Color 
{ 
  Red, 
  White, 
  Blue 
}  

 public enum Color
 {
   Red,
   White,
   Blue
 }

然后可以这样来使用Color myColor = Color.Red.
枚举类型还提供了两个有用的静态方法values()和valueOf().　我们可以很方便地使用它们，例如

1 for (Color c : Color.values())
2 System.out.println(c);

5.可变参数(Varargs)
可变参数使程序员可以声明一个接受可变数目参数的方法。注意，可变参数必须是函数声明中的最后一个参数。假设我们要写一个简单的方法打印一些对象，

util.write(obj1);
util.write(obj1,obj2);
util.write(obj1,obj2,obj3);
…

在JDK1.5之前，我们可以用重载来实现，但是这样就需要写很多的重载函数，显得不是很有效。如果使用可变参数的话我们只需要一个函数就行了

1 public void write(Object… objs) {
2 for (Object obj: objs)
3 System.out.println(obj);
4 }

在引入可变参数以后，Java的反射包也更加方便使用了。对于c.getMethod(“test”, new Object[0]).invoke(c.newInstance(), new Object[0]))，现在我们可以这样写了c.getMethod(“test”).invoke(c.newInstance())，这样的代码比原来清楚了很多。
6.静态导入(Static Imports)
要使用用静态成员（方法和变量）我们必须给出提供这个方法的类。使用静态导入可以使被导入类的所有静态变量和静态方法在当前类直接可见，使用这些静态成员无需再给出他们的类名。

import static java.lang.Math.*;
…….

r = sin(PI * 2); //无需再写r = Math.sin(Math.PI);

不过，过度使用这个特性也会一定程度上降低代码地可读性。

二． 重点讲一下泛型

在已发布的Java1.4中在核心代码库中增加了许多新的API(如Loging,正则表达式，NIO)等，在最新发布的JDK1.5和即将发布的JDK1.6中也新增了许多API，其中比较有重大意义的就是Generics(范型)。

1.什么是Generics?

Generics可以称之为参数类型(parameterized types),由编译器来验证从客户端将一种类型传送给某一对象的机制。如Java.util.ArrayList,编译器可以用Generics来保证类型安全。

在我们深入了解Generics之前,我们先来看一看当前的java集合框架(Collection)。在j2SE1.4中所有集合的Root Interface是Collection

[java]
protected void collectionsExample() { 
   ArrayList list = new ArrayList(); 
   list.add(new String(“test string”)); 
   list.add(new Integer(9)); // purposely placed here to create a runtime ClassCastException  
   inspectCollection(list); 
} 
protected void inspectCollection(Collection aCollection) { 
   Iterator i = aCollection.iterator(); 
   while (i.hasNext()) { 
      String element = (String) i.next(); 
   } 
}  

 protected void collectionsExample() {
    ArrayList list = new ArrayList();
    list.add(new String(“test string”));
    list.add(new Integer(9)); // purposely placed here to create a runtime ClassCastException
    inspectCollection(list);
 }
 protected void inspectCollection(Collection aCollection) {
    Iterator i = aCollection.iterator();
    while (i.hasNext()) {
       String element = (String) i.next();
    }
 }

以上的样例程序包含的两个方法，collectionExample方法建立了一个简单的集合类型ArrayList，并在ArrayList中增加了一个String和一个Integer对象.而在inspecCollection方法中，我们迭代这个ArrayList用String进行Cast。我们看第二个方法，就出现了一个问题,Collection在内部用的是Object，而我们要取出Collection中的对象时,需要进行Cast，那么开发者必需用实际的类型进行Cast,像这种向下造型，编译器无

法进行检查,如此一来我们就要冒在代码在运行抛出ClassCastException的危险。我们看inspecCollection方法，编译时没有问题，但在运行时就会抛出ClassCastException异常。所以我们一定要远离这个重大的运行时错误

2.使用Generics

从上一章节中的CassCastException这种异常，我们期望在代码编译时就能够捕捉到,下面我们使用范型修改上一章的样例程序。

[java]
protected void collectionsExample() { 
 ArrayList list = new ArrayList(); 
 list.add(new String(“test string”)); 
 // list.add(new Integer(9)); this no longer compiles  
 inspectCollection(list); 
} 
protected void inspectCollection(Collection aCollection) { 
 Iterator i = aCollection.iterator(); 
 while(i.hasNext()) { 
  String element = i.next(); 
 } 
}  

 protected void collectionsExample() {
  ArrayList list = new ArrayList();
  list.add(new String(“test string”));
  // list.add(new Integer(9)); this no longer compiles
  inspectCollection(list);
 }
 protected void inspectCollection(Collection aCollection) {
  Iterator i = aCollection.iterator();
  while(i.hasNext()) {
   String element = i.next();
  }
 }

从上面第2行我们在创建ArrayList时使用了新语法，在JDK1.5中所有的Collection都加入了Generics的声明。例:

[java]
public class ArrayList extends AbstractList { 
  // details omitted…  
  public void add(E element) { 
   // details omitted  
  } 
  public Iterator iterator() { 
   // details omitted  
  } 
}  

 public class ArrayList extends AbstractList {
  // details omitted…
  public void add(E element) {
   // details omitted
  }
  public Iterator iterator() {
   // details omitted
  }
}

这个E是一个类型变量，并没有对它进行具体类型的定义,它只是在定义ArrayList时的类型占位符,在Example 2中的我们在定义ArrayList的实例时用String绑定在E上,当我们用add(E element)方法向ArrayList中增加对象时,那么就像下面的写法一样: public void add(String element);因为在ArrayList所有方法都会用String来替代E,无论是方法的参数还是返回值。这时我们在看Example 2中的第四行，编译就会反映出编译错误。

所以在java中增加Generics主要的目的是为了增加类型安全。

通过上面的简单的例子我们看到使用Generics的好处有:

· 1.在类型没有变化时，Collection是类型安全的。

· 2.内在的类型转换优于在外部的人工造型。

· 3.使Java接口更加强壮,因为它增加了类型。

· 4.类型的匹配错误在编译阶段就可以捕捉到，而不是在代码运行时。

受约束类型变量

虽然许多Class被设计成Generics，但类型变量可以是受限的

public class C1 { }
public class C2 { }

第一个T变量必须继承Number，第二个T必须继承Person和实现Comparable

3.Generics方法

像Generics类一样，方法和构造函数也可以有类型参数。方法的参数的返回值都可以有类型参数，进行Generics。

//Example 4

1 public T max(T t1, T t2) {
2  if (t1.compareTo(t2) > 0)
3   return t1;
4  else return t2;
5 }

这里，max方法的参数类型为单一的T类型，而T类型继承了Comparable，max的参数和返回值都有相同的超类。下面的Example 5显示了max方法的几个约束。

//Example 5

1 Integer iresult = max(new Integer(100), new Integer(200));
2 String sresult = max(“AA”, “BB”);
3 Number nresult = max(new Integer(100), “AAA”); // does not compile

在Example 5第1行参数都为Integer，所以返回值也是Integer，注意返回值没有进行造型。

在Example 5第2行参数都为String，所以返回值也是String，注意返回值没有进行造型。以上都调用了同一个方法。

在Example 5第3行产生以下编译错误:

Example.java:10: incompatible types
found  : java.lang.Object&java.io.Serializable&java.lang.Comparable
required: java.lang.Number
    Number nresult = max(new Integer(100), “AAA”);

这个错误发生是因为编译器无法确定返回值类型，因为String和Integer都有相同的超类Object,注意就算我们修正了第三行，这行代码在运行仍然会报错，因为比较了不同的对象。

3.通配(Wildcards)

先看以下两行代码是否合法:
List ls = new ArrayList(); // 1
List