Java1.5新特性

jdk 1.5新特性说明

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

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

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

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

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

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

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

　　编译器会给出一个错误：

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

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

1 void processAll(Collection c){
2 for(Iterator i=c.iterator(); i.hasNext();){
3 MyClass myObject = (MyClass)i.next();
4 myObject.process();
5 }
6 }

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

1 void processAll(Collection<MyClass> c){
2 for (MyClass myObject :c)
3 myObject.process();
4 }

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

3.自动装包/拆包(Autoboxing/unboxing)
自动装包/拆包大大方便了基本类型数据和它们包装类地使用。
自动装包：基本类型自动转为包装类.(int >> Integer)
自动拆包：包装类自动转为基本类型.(Integer >> int)
　　在JDK1.5之前，我们总是对集合不能存放基本类型而耿耿于怀，现在自动转换机制解决了我们的问题。

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

　　这里Integer先自动转换为int进行加法运算，然后int再次转换为Integer.
4.枚举(Enums)
JDK1.5加入了一个全新类型的“类”－枚举类型。为此JDK1.5引入了一个新关键字enmu.　我们可以这样来定义一个枚举类型。

1 public enum Color
2 {
3 Red,
4 White,
5 Blue
6 }

　　然后可以这样来使用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

Collections example without genericity: Example 1

1 protected void collectionsExample() {
2  ArrayList list = new ArrayList();
3  list.add(new String("test string"));
4  list.add(new Integer(9)); // purposely placed here to create a runtime ClassCastException
5  inspectCollection(list);
6 }
7
8
9 protected void inspectCollection(Collection aCollection) {
10  Iterator i = aCollection.iterator();
11  while (i.hasNext()) {
12   String element = (String) i.next();
13  }
14 }

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

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

2.使用Generics

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

//Example 2

1 protected void collectionsExample() {
2  ArrayList<String> list = new ArrayList<String>();
3  list.add(new String("test string"));
4  // list.add(new Integer(9)); this no longer compiles
5  inspectCollection(list);
6 }
7
8
9 protected void inspectCollection(Collection<String> aCollection) {
10  Iterator<String> i = aCollection.iterator();
11  while(i.hasNext()) {
12   String element = i.next();
13  }
14 }

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

//Example 3

1 public class ArrayList<E> extends AbstractList<E> {
2  // details omitted...
3  public void add(E element) {
4   // details omitted
5  }
6  public Iterator<E> iterator() {
7   // details omitted
8  }
9 }

　 　这个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<T extends Number> { }
public class C2<T extends Person & Comparable> { }

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

3.Generics方法

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

//Example 4

1 public <T extends Comparable> 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<String> ls = new ArrayList<String>(); // 1
List<Object> lo = ls; // 2
第一行没问题, 关键在第二行代码, 大多数人会认为, "一个String的List自然更是一个Object的List", 因此, 第2行没问题.

好, 接着看以下代码:
lo.add(new Object()); // 3
String s = ls.get(0); // 4: 试图将一个Object赋给一个String!
可见, 通过别名lo, 我们能对ls, 一个String的列表, 进行数据操作(特别是插入一个Object), 从而导致ls不仅仅是容纳了String对象! 这是Java编译器不容许的! 编译时, 第2行会报告一个编译错误的.

通常, 若Foo是Bar的一个子类型(子类或子接口), G是某个泛型声明, 则G<Foo>并不是G<Bar>的一个子类型.

假定要输出一个集合中的所有元素. 以下分别是旧版本及新版本(JDK 1.5)中的写法:

void printCollection(Collection c) {
  Iterator i = c.iterator();
  for( k = 0; k < c.size(); k++) {
    System.out.println( i.next() );
}}

void printCollection(Collection<Object> c) {
  for(Object e : c) {
    System.out.println(e);
}}

问 题在于, 新版本反而不如旧版本更有用些. 因为旧版本能使用各种类型的集合作为参数, 但新版本则只能使用Collection<Object>. 而正如上节看到的, Collection<Object>并不是其它各种集合的超类型(父类型).

所有集合的超类型应该写作: Collection<?>, 读作: collection of unknown(未知集合), 即一个集合, 其元素类型可以与任何类型相匹配. 因此称这种类型为"通配类型".

正确实现上述旧版本的代码可以这么写:
void printCollection(Collection<?> c) {
  for(Object e : c) {
    System.out.println(e);
}}

这时, 可以用任意类型的集合来调用此方法. 注意在方法体中, 仍然从 c 中读入元素并赋给了Object, 这是没有错误的, 因此不论类型实参是何种集合, 它的元素都是object. 然而, 如果任意给它增加一个object则是不安全的:

Collection<?> c = new ArrayList<String>();
c.add(new Object()); // 编译时的错误

由 于我们不知道c的元素类型是什么, 所以不能给它增加一个object. 方法add()接受一个类型E的参数, 而E与集合的元素类型相同. 当类型实参是?时, 它表示"未知的类型", 我们传递给add的参数必须是这个"未知类型"的子类型. 不幸的是, 既然类型未知, 也就无法决定其子类型, 于是什么也不能作为其参数. 唯一的例外是null, 因为null是所有类型的一个成员.

另一方面, 如果给了一个List<?>, 我们可以调用get()方法并使用其返回的元素. 虽然返回的元素类型是"未知类型", 但它总归是一个object, 因此将get()返回的元素赋给一个Object类型的变量, 或将其传递给一个可接受Object的参数都是安全的.















Java2标准版(Java 2 Platform, Standard Edition, J2SE)1.5即将正式推出，这一次的版本更新不同于以往，它带来了很多里程碑式的革新，SUN将其绰号取名为“虎”。这一次的变革将是Java诞生以 来从未有过的，它给我们带来了耳目一新的感觉。下面我们就来欣赏一下其中的部分典型变化：
　　
　　1.自动包装和解包(Autoboxing and unboxing)
　　代码示例
　　
　　往一个ArrayList中加入一个整数，1.5版本以前的版本写法是：
　　
　　List list = new ArrayList();
　　
　　list.add( new Integer( 10 ) );
　　
　　而在1.5版本中可以写为：
　　
　　list.add( 10 );
　　
　 　因为，在1.5版本中，对一个整数进行包装，使之成为一个Integer对象(即包装，boxing)，然后加入到一个ArrayList中的做法被认 为是没有必要的，反之，解包(unboxing)的做法也是没有必要的，这样的代码只是增加了程序的文本长度而已，所以1.5版本支持了自动包装和解包操 作，对于bool/Boolean，byte/Byte，double/Double，short/Short，int/Integer，long /Long，float/Float的相应包装/解包操作都进行了支持，从而使代码变得简单。
　　
　　2.更优化的循环语句(The inhanced for loop)
　　代码示例
　　
　　一个典型的遍历数组的循环语句，1.5版本以前的写法是：
　　
　　for ( Iterator iterator = list.iterator(); iterator.hasNext(); )
　　
　　{
　　
　　Integer n = (Integer)iterator.next();
　　
　　...
　　
　　}//for
　　
　　而在1.5版本中可以写为：
　　
　　for ( Integer n : list )
　　
　　{
　　
　　...
　　
　　}//for
　　
　　显然1.5版本的写法比以前是大大简化了，但是在需要修改集合，比如删除其中元素时不能采用这种写法。之所以Java1.5版本没有象C#那样干脆定义一个foreach关键词，主要是因为SUN认为增加一个专门的关键词成本太高了(too costly)。但1.4版本中就曾经增加了assert关键词，1.5版本中也新增加了enum关键词，因此这一解释恐怕并不那么令人信服。
　　
　　3.参数可变的方法和printf
　　代码示例
　　
　　当不能确定一个方法的入口参数的个数时，以往版本的Java中，通常的做法是将多个参数放在一个数组或者对象集合中作为参数来传递，1.5版本以前的写法是：
　　
　　int sum(Integer[] numbers)
　　
　　{
　　
　　int nSum = 0;
　　
　　for(int i: numbers)
　　
　　nSum += i;
　　
　　return nSum;
　　
　　}
　　
　　...
　　
　　//在别处调用该方法
　　
　　sum(new Integer[] {12,13,20});
　　
　　而在1.5版本中可以写为：
　　
　　int sum(Integer... numbers)
　　
　　{
　　
　　int nSum = 0;
　　
　　for(int i: numbers)
　　
　　nSum += i;
　　
　　return nSum;
　　
　　}
　　
　　...
　　
　　//在别处调用该方法
　　
　　sum(12,13,20);
　　
　　显然，1.5版本的写法更为简易，也更为直观，尤其是方法的调用语句，不仅简化很多，而且更符合通常的思维方式，更易于理解。
　　
　　1.5版本自身就有一个应用该特征的典型例子，即C风格的格式化输出方法——printf。
　　
　　代码示例
　　
　　输出一个加法算式，1.5版本以前的写法是：
　　
　　int x = 5;
　　
　　int y = 7;
　　
　　int nSum = x + y;
　　
　　System.out.println(x + " + " + y + " = " + nSum);
　　
　　而在1.5版本中可以写为：
　　
　　System.out.printf("%d + %d = %d/n", x, y, nSum);
　　
　　以上两种写法的输出结构是一样的，即“5 + 7 = 12”。
　　
　 　这种改变不仅仅是形式上的，printf还可以提供更为灵活、强大的输出功能，比如限定按照两位整数的形式输出，可以写为 “System.out.printf("%02d + %02d = %02d/n", x, y, nSum);”，输出结果将是“05 + 07 = 12”。
　　
　　4.枚举
　　代码示例
　　
　　构建一个表示色彩的枚举，并赋值，在1.5版本中可以写为：
　　
　　public enum MyColor{ Red, Yellow, Blue }
　　
　　MyColor color = MyColor.Red;
　　
　　for ( MyColor mycolor : MyColor.values() )
　　
　　System.out.println( mycolor );
　　
　 　以往的Java版本中没有enum关键词，1.5版本中终于加入了进来，这确实是一个令人高兴的改进。此外，enum还提供了一个名为values() 的静态方法，用以返回枚举的所有值的集合。所以，以上程序的输出结果是把“Red”、“Yellow”、“Blue”分行输出。
　　
　　 而enum提供的静态方法valueOf()则将以字符串的形式返回某一个具体枚举元素的值，比如“MyColor.valueOf(“Red”)”会返 回“Color.Red”。静态方法name()则返回某一个具体枚举元素的名字，比如“MyColor.Red.name()”会返回“Red”。类似 的方法还有不少。此外，enum自身还可以有构造方法。
　　
　　5.静态引用
　　代码示例
　　
　　当我们要获取一个随即数时，1.5版本以前的写法是：
　　
　　import java.lang.Math; //程序开头处
　　
　　...
　　
　　double x = Math.random();
　　
　　而在1.5版本中可以写为：
　　
　　import static java.lang.Math.random; //程序开头处
　　
　　…
　　
　　double x = random();
　　
　　静态引用使我们可以象调用本地方法一样调用一个引入的方法，当我们需要引入同一个类的多个方法时，只需写为“import static java.lang.Math.*”即可。这样的引用方式对于枚举也同样有效。
　　
　　6.总结
　　以上对J2SE1.5的部分新特征做了一些简单的介绍。总而言之，1.5版本的Java确实给我们带来了很多令人激动的变革，如同以上介绍的那样，很多功能以前的版本也能实现，但是不能实现得这样简单、漂亮。相信这次变革会给Java带来更多的追随者。