J2SE(TM) 5.0专题 之 语言特性

J2SE(TM) 5.0专题 之 语言特性

[准备工作]



首先，为了了解J2SE(TM) 5.0的新的语言特性，你需要下载新版的JDK，在这里可以找到
下载链接：http://java.sun.com/j2se/1.5.0/download.jsp。当然，如果你已经有过手
动配置Java环境的经历，我也建议你使用一个支持J2SE(TM) 5.0的IDE，推荐Eclipse
SDK 3.1 M4，或者NetBeans IDE 4.0。两个都是开源免费的，且很容易找到（Eclipse不
用说了，NetBeans IDE 4.0有与JDK 5.0 Update 1的捆绑版）。



说点题外话，Java的版本号自从1.2开始，似乎就多少显得有点蹩脚。从1.2版本开始，
Java (J2SE)被称作Java 2，而不是Java 1.2，现在则显得更加离奇：Java(TM) 2
Platform Standard Edition 5.0或者J2SE(TM) 5.0，而内部的版本号还是1.5.0。那么
到底是1、2、还是5呢？来看看Sun官方网站是怎么说的：



从Java诞生至今已有9年时间，而从第二代Java平台J2SE算起也有5个年头了。在这样的
背景下，将下一个版本的版本号从1.5改为5.0可以更好的反映出新版J2SE的成熟度、稳
定性、可伸缩性和安全性。



好吧，现在我们将面对如下一些名称，而它们指的基本上是同一个东西：

Tiger

Java(TM) 2 Platform Standard Edition 5.0

J2SE(TM) 5.0

Java version 1.5.0

…

在本文中，为了方便起见，我将统一使用J2SE(TM) 5.0这个名称。



如果你对Java各个版本的代号感兴趣，就像这里的"Tiger"，可以参考如下网址：
http://java.sun.com/j2se/codenames.html。透露一点：Java下一个版本（6.0）的代
号是"Mustang"野马，再下一个版本（7.0）的代号是"Dolphin"海豚。





[概述]



J2SE(TM) 5.0引入了很多激进的语言元素变化，这些变化或多或少减轻了我们开发人员
的一些编码负担，其中的大部分也必然会被应用到即将发布的J2EE(TM) 5.0中。主要的
新特性包括：



1-      泛型

2-      增强的for循环

3-      自动装箱和自动拆箱

4-      类型安全的枚举

5-      可变长度参数

6-      静态引入

7-      元数据（注解）

8-      C风格的格式化输出



这当中，泛型、枚举和注解可能会占用较大的篇幅，而其余的因为用法相当直截了当，
抑或相对简单，我就稍作介绍，剩下的留给读者去思考、去探索了。





[泛型]



泛型这个题目相当大，大到完全可以就这个话题写一本书。有关Java是否需要泛型和如
何实现泛型的讨论也早就在Java社群广为流传。终于，我们在J2SE(TM) 5.0中看到了
它。也许目前Java对泛型的支持还算不上足够理想，但这一特性的添加已经足以让我们
欣喜一阵了。



在接下来的介绍中，我们会了解到：Java的泛型虽然跟C++的泛型看上去十分相似，但其
实有着相当大的区别，有些细节的东西也相当难以掌握（至少很多地方会跟我们的直觉
背道而驰）。可以这样说，泛型的引入在很大程度上增加了Java语言的复杂度，对初学
者尤其是个挑战。我们一点一点往里挖。



首先我们来看一个简单的使用泛型类的例子：



    ArrayList<Integer> aList = new ArrayList<Integer>();

    aList.add(new Integer(1));

    // ...

    Integer myInteger = aList.get(0);



我们可以看到，在这个简单的例子中，我们在定义aList的时候指明了它是一个直接受
Integer类型的ArrayList，当我们调用aList.get(0)时，我们已经不再需要先显式的将
结果转换成Integer，然后再赋值给myInteger了。而这一步在早先的Java版本中是必须
的。也许你在想，在使用Collection时节约一些类型转换就是Java泛型的全部吗？远不
止。单就这个例子而言，泛型至少还有一个更大的好处，那就是使用了泛型的容器类变
得更加健壮：早先，Collection接口的get()和Iterator接口的next()方法都只能返回
Object类型的结果，我们可以把这个结果强制转换成任何Object的子类，而不会有任何
编译期的错误，但这显然很可能带来严重的运行期错误，因为在代码中确定从某个
Collection中取出的是什么类型的对象完全是调用者自己说了算，而调用者也许并不清
楚放进Collection的对象具体是什么类的；就算知道放进去的对象“应该”是什么类，
也不能保证放到Collection的对象就一定是那个类的实例。现在有了泛型，只要我们定
义的时候指明该Collection接受哪种类型的对象，编译器可以帮我们避免类似的问题溜
到产品中。我们在实际工作中其实已经看到了太多的ClassCastException，不是吗？



泛型的使用从这个例子看也是相当易懂。我们在定义ArrayList时，通过类名后面的<>括
号中的值指定这个ArrayList接受的对象类型。在编译的时候，这个ArrayList会被处理
成只接受该类或其子类的对象，于是任何试图将其他类型的对象添加进来的语句都会被
编译器拒绝。



那么泛型是怎样定义的呢？看看下面这一段示例代码：（其中用E代替在实际中将会使用
的类名，当然你也可以使用别的名称，习惯上在这里使用大写的E，表示Collection的元
素。）



    public class TestGenerics<E> {

        Collection<E> col;

        public void doSth(E elem) {

            col.add(elem);

            // ...

        }

    }



在泛型的使用中，有一个很容易有的误解，那就是既然Integer是从Object派生出来的，
那么ArrayList<Integer>当然就是ArrayList<Object>的子类。真的是这样吗？我们仔细
想一想就会发现这样做可能会带来的问题：如果我们可以把ArrayList<Integer>向上转
型为ArrayList<Object>，那么在往这个转了型以后的ArrayList中添加对象的时候，我
们岂不是可以添加任何类型的对象（因为Object是所有对象的公共父类）？这显然让我
们的ArrayList<Integer>失去了原本的目的。于是Java编译器禁止我们这样做。那既然
是这样，ArrayList<Integer>以及ArrayList<String>、ArrayList<Double>等等有没有
公共的一个版本来代替所有呢？有，那就是ArrayList<?>。?在这里叫做通配符。我们为
了缩小通配符所指代的范围，通常也需要这样写：ArrayList<? extends SomeClass>，
这样写的含义是定义的是这样一类ArrayList，比方说SomeClass有SomeExtendedClass1
和SomeExtendedClass2这两个子类，那么ArrayList<? extends SomeClass>就是如下几
个类型的通配写法：ArrayList<SomeClass>、ArrayList<SomeExtendedClass1>和
ArrayList<SomeExtendedClass2>。



接下来我们更进一步：既然ArrayList<? extends SomeClass>是一个通配的写法，那么
我们可不可以往声明为ArrayList<? extends SomeClass>的ArrayList实例中添加一个
SomeExtendedClass1的对象呢？答案是不能。甚至你不能添加任何对象。为什么？因为
ArrayList<? extends SomeClass>实际上代表了所有ArrayList<SomeClass>、
ArrayList<SomeExtendedClass1>和ArrayList<SomeExtendedClass2>三种ArrayList，甚
至包括未知的接受SomeClass其他子类对象的ArrayList。我们拿到一个定义为
ArrayList<? extends SomeClass>的ArrayList的时候，我们并不能确定这个ArrayList
具体是使用哪个类作为参数定义的，因此编译器也无法让这段代码编译通过。举例来
讲，如果我们想往这个ArrayList中放一个SomeExtendedClass2的对象，我们如何保证它
实际上不是其他的如ArrayList<SomeExtendedClass1>，而就是这个
ArrayList<SomeExtendedClass2>呢？（还记得吗？ArrayList<Integer>并非
ArrayList<Object>的子类。）怎么办？我们需要使用泛型方法。泛型方法的定义类似下
面的例子：



    public static <T extends SomeClass> void add (Collection<T> c, T elem) {

        c.add(elem);

    }



其中T代表了我们这个方法期待的那个最终的具体的类，相关的声明必须放在方法签名的
紧靠返回类型说明之前。在本例中，它可以是SomeClass或者SomeClass的任何子类，其
说明<T entends SomeClass>放在void关键字之前（只能放在这里）。这样我们就可以让
编译器确信当我们试图添加一个元素到泛型的ArrayList实例中时，可以保证类型安全。



Java泛型的最大特点在于它是在语言级别实现的，区别于C# 2.0中的CLR级别。这样的做
法使得JRE可以不必做大的调整，缺点是无法支持一些运行时的类型甄别。一旦编译，它
就被写死了，能都提供的动态能力相当弱。



个人认为泛型是这次J2SE(TM) 5.0中引入的最重要的语言元素，给Java语言带来的影响
也是最大。举个例子来讲，我们可以看到，几乎所有的Collections API都被更新成支持
泛型的版本。这样做带来的好处是显而易见的，那就是减少代码重复（不需要提供多个
版本的某一个类或者接口以支持不同类的对象）以及增强代码的健壮性（编译期的类型
安全检查）。不过如何才能真正利用好这个特性，尤其是如何实现自己的泛型接口或类
供他人使用，就并非那么显而易见了。让我们一起在使用中慢慢积累。





[增强的for循环]



你是否已经厌倦了每次写for循环时都要写上那些机械的代码，尤其当你需要遍历数组或
者Collection，如：（假设在Collection中储存的对象是String类型的）



public void showAll (Collection c) {

    for (Iterator iter = c.iterator(); iter.hasNext(); ) {

        System.out.println((String) iter.next());

    }

}



public void showAll (String[] sa) {

    for (int i = 0; i < sa.length; i++) {

        System.out.println(sa[i]);

    }

}



这样的代码不仅显得臃肿，而且容易出错，我想我们大家在刚开始接触编程时，尤其是
C/C++和Java，可能多少都犯过以下类似错误的一种或几种：把for语句的三个表达式顺
序弄错；第二个表达式逻辑判断不正确（漏掉一些、多出一些、甚至死循环）；忘记移
动游标；在循环体内不小心改变了游标的位置等等。为什么不能让编译器帮我们处理这
些细节呢？在5.0中，我们可以这样写：



public void showAll (Collection c) {

    for (Object obj : c) {

        System.out.println((String) obj);

    }

}



public void showAll (String[] sa) {

    for (String str : sa) {

        System.out.println(str);

    }

}



这样的代码显得更加清晰和简洁，不是吗？具体的语法很简单：使用":"分隔开，前面的
部分写明从数组或Collection中将要取出的类型，以及使用的临时变量的名字，后面的
部分写上数组或者Collection的引用。加上泛型，我们甚至可以把第一个方法变得更加
漂亮：



public void showAll (Collection<String> cs) {

    for (String str : cs) {

        System.out.println(str);

    }

}



有没有发现：当你需要将Collection<String>替换成String[]，你所需要做的仅仅是简
单的把参数类型"Collection<String>"替换成"String[]"，反过来也是一样，你不完全
需要改其他的东西。这在J2SE(TM) 5.0之前是无法想象的。



对于这个看上去相当方便的新语言元素，当你需要在循环体中访问游标的时候，会显得
很别扭：比方说，当我们处理一个链表，需要更新其中某一个元素，或者删除某个元素
等等。这个时候，你无法在循环体内获得你需要的游标信息，于是需要回退到原先的做
法。不过，有了泛型和增强的for循环，我们在大多数情况下已经不用去操心那些烦人的
for循环的表达式和嵌套了。毕竟，我们大部分时间都不会需要去了解游标的具体位置，
我们只需要遍历数组或Collection，对吧？





[自动装箱/自动拆箱]



所谓装箱，就是把值类型用它们相对应的引用类型包起来，使它们可以具有对象的特
质，如我们可以把int型包装成Integer类的对象，或者把double包装成Double，等等。
所谓拆箱，就是跟装箱的方向相反，将Integer及Double这样的引用类型的对象重新简化
为值类型的数据。



在J2SE(TM) 5.0发布之前，我们只能手工的处理装箱和拆箱。也许你会问，为什么需要
装箱和拆箱？比方说当我们试图将一个值类型的数据添加到一个Collection中时，就需
要先把它装箱，因为Collection的add()方法只接受对象；而当我们需要在稍后将这条数
据取出来，而又希望使用它对应的值类型进行操作时，我们又需要将它拆箱成值类型的
版本。现在，编译器可以帮我们自动地完成这些必要的步骤。下面的代码我提供两个版
本的装箱和拆箱，一个版本使用手工的方式，另一个版本则把这些显而易见的代码交给
编译器去完成：



public static void manualBoxingUnboxing(int i) {

    ArrayList<Integer> aList = new ArrayList<Integer>();

    aList.add(0, new Integer(i));

    int a = aList.get(0).intValue();

    System.out.println("The value of i is " + a);

}



public static void autoBoxingUnboxing(int i) {

    ArrayList<Integer> aList = new ArrayList<Integer>();

    aList.add(0, i);

    int a = aList.get(0);

    System.out.println("The value of i is " + a);

}



看到了吧，在J2SE(TM) 5.0中，我们不再需要显式的去将一个值类型的数据转换成相应
的对象，从而把它作为对象传给其他方法，也不必手工的将那个代表一个数值的对象拆
箱为相应的值类型数据，只要你提供的信息足够让编译器确信这些装箱/拆箱后的类型在
使用时是合法的：比方讲，如果在上面的代码中，如果我们使用的不是
ArrayList<Integer>而是ArrayList或者其他不兼容的版本如
ArrayList<java.util.Date>，会有编译错误。



当然，你需要足够重视的是：一方面，对于值类型和引用类型，在资源的占用上有相当
大的区别；另一方面，装箱和拆箱会带来额外的开销。在使用这一方便特性的同时，请
不要简单的忘记了背后隐藏的这些也许会影响性能的因素。





[类型安全的枚举]



在介绍J2SE(TM) 5.0中引入的类型安全枚举的用法之前，我想先简单介绍一下这一话题
的背景。



我们知道，在C中，我们可以定义枚举类型来使用别名代替一个集合中的不同元素，通常
是用于描述那些可以归为一类，而又有限数量的类别或者概念，如月份、颜色、扑克
牌、太阳系的行星、五大洲、四大洋、季节、学科、四则运算符，等等。它们通常看上
去是这个样子：



typedef enum {SPRING, SUMMER, AUTUMN, WINTER} season;



实质上，这些别名被处理成int常量，比如0代表SPRING，1代表SUMMER，以此类推。因为
这些别名最终就是int，于是你可以对它们进行四则运算，这就造成了语意上的不明确。



Java一开始并没有考虑引入枚举的概念，也许是出于保持Java语言简洁的考虑，但是使
用Java的广大开发者对于枚举的需求并没有因为Java本身没有提供而消失，于是出现了
一些常见的适用于Java的枚举设计模式，如int enum和typesafe enum，还有不少开源的
枚举API和不开源的内部实现。



我大致说一下int enum模式和typesafe enum模式。所谓int enum模式就是模仿C中对
enum的实现，如：



public class Season {

    public static final int SPRING = 0;

    public static final int SUMMER = 1;

    public static final int AUTUMN = 2;

    public static final int WINTER = 3;

}



这种模式跟C中的枚举没有太多本质上的区别，C枚举的局限它基本上也有。而typesafe
enum模式则要显得健壮得多：



public class Season {

    private final String name;

    private Season(String name) {

        this.name = name;

    }

    public String toString() {

        return name;

    }

    public static final Season SPRING = new Season("spring");

    public static final Season SUMMER = new Season("summer");

    public static final Season AUTUMN = new Season("autumn");

    public static final Season WINTER = new Season("winter");

}



后一种实现首先通过私有的构造方法阻止了对该类的继承和显式实例化，因而我们只可
能取得定义好的四种Season类别，并且提供了方便的toString()方法获取有意义的说
明，而且由于这是一个完全意义上的类，所以我们可以很方便的加入自己的方法和逻辑
来自定义我们的枚举类。



最终，Java决定拥抱枚举，在J2SE(TM) 5.0中，我们看到了这一变化，它所采用的设计
思路基本上就是上面提到的typesafe enum模式。它的语法很简单，用一个实际的例子来
说，要定义一个枚举，我们可以这样写：



public enum Language {CHINESE, ENGLISH, FRENCH, HUNGARIAN}



接下来我们就可以通过Language.ENGLISH来使用了。呃…这个例子是不是有点太小儿科
了，我们来看一个复杂点的例子。使用Java的类型安全枚举，我们可以为所有枚举元素
定义公用的接口，然后具体到每个元素本身，可以针对这些接口实现一些特定的行为。
这对于那些可以归为一类，又希望能通过统一的接口访问的不同操作，将会相当方便。
通常，为了实现类似的功能，我们需要自己来维护一套继承关系或者类似的枚举模式。
借用Java官网上的例子：



public enum Operation {

    PLUS   { double eval(double x, double y) { return x + y; } },

    MINUS  { double eval(double x, double y) { return x - y; } },

    TIMES  { double eval(double x, double y) { return x * y; } },

    DIVIDE { double eval(double x, double y) { return x / y; } };



    // Do arithmetic op represented by this constant

    abstract double eval(double x, double y);

}



在这个枚举中，我们定义了四个元素，分别对应加减乘除四则运算，对于每一种运算，
我们都可以调用eval()方法，而具体的方法实现各异。我们可以通过下面的代码来试验
上面这个枚举类：



public static void main(String args[]) {

    double x = Double.parseDouble(args[0]);

    double y = Double.parseDouble(args[1]);

    for (Operation op : Operation.values()) {

        System.out.println(x + " " + op + " " + y + " = " + op.eval(x, y));

    }

}



怎么样，使用枚举，我们是不是能够很方便的实现一些有趣的功能？其实说穿了，Java
的类型安全枚举就是包含了有限数量的已生成好的自身实例的一种类，这些现成的实例
可以通过类的静态字段来获取。





[可变长度参数]



顾名思义，可变长度参数就是指在方法的参数体中，只要定义恰当，我们可以使用任意
数量的参数，类似于使用数组。在J2SE(TM) 5.0中，一个新的语法被引入，就是在参数
类型名称后面加上"..."，表示该方法可以接受多个该类型的参数。需要说明的是可变长
度参数必须放在参数列表的最后，且一个方法只能包含一个这样的参数。在方法体内
部，这样的参数被当作数组处理，看上去代码应该类似这个样子：



public String testVararg(String... args) {

    StringBuilder sb = new StringBuilder();

    for (String str : args) {

        sb.append(str);

    }

    return sb.toString();

}



这样的方法签名跟你写成testVararg(String[] args)的区别在于：在调用时，你不再需
要传入一个包装好的String数组，你只需要简单的写一连串String参数，以逗号隔开即
可，就如同这个方法正好有一个重载的版本是接受那么多个String参数一样。





[静态引入]



所谓静态引入就是指除了引入类之外，我们现在又多了一种选择：引入某个类的静态字
段。如：



import static java.lang.Math.PI;

或者

import static java.lang.Math.*;



这样我们在接下来的代码中，当我们需要使用某个被引入的静态字段时，就不用再写上
前面的类名了。当然，出现名字冲突时，跟原来的类引入一样，还是需要前缀以示区
分。我个人认为这个新语言元素意义不大。当引入太多静态字段后，代码会变得难以阅
读和维护。由于静态字段的名字通常不如类名那么具有描述性，我认为原先在静态字段
前写上类名才是更好的选择。不过，毕竟每个人的喜好和需求不同，如果你觉得它对你
有用，既然提供了，那么就用咯。





[元数据（注解）]



注解是J2SE(TM) 5.0引入的重要语言元素，它所对应的JSR是JSR 175，我们先来看看
JSR 175的文档对注解的说明：



注解不会直接影响程序的语义，而开发和部署工具则可以读取这些注解信息，并作相应
处理，如生成额外的Java源代码、XML文档、或者其他将与包含注解的程序一起使用的物
件。



在之前的J2SE版本中，我们已经使用到了一部分早期的注解元素，如@deprecated等。这
些元素通常被用于产生HTML的Javadoc。在J2SE(TM) 5.0中，注解被正式引入，且推到了
Java历史上前所未有的高度。



现在，注解不仅仅被用来产生Javadoc，更重要的，注解使得代码的编译期检查更加有效
和方便，同时也增强了代码的描述能力。有一些注解是随着J2SE(TM) 5.0一起发布的，
我们可以直接使用。除此之外，我们也可以很方便的实现自定义的注解。在此基础上，
很多以前我们只能靠反射机制来完成的功能也变得更加容易实现。



我们来看现成的有哪些有用的注解：



首先是@Override，这个注解被使用在方法上，表明这个方法是从其父类继承下来的，这
样的写法可以很方便的避免我们在重写继承下来的方法时，不至于不小心写错了方法签
名，且悄悄的溜过了编译器，造成隐蔽性相当高的bug。



其次是@Deprecated，表明该项（类、字段、方法）不再被推荐使用。



还有一个@SuppressWarnings，表明该项（类、字段、方法）所涵盖的范围不需要显示所
有的警告信息。这个注解需要提供参数，如unchecked等等。



下面我通过一个例子向大家说明这些现成的注解的用法：



public class Main {

    @Deprecated

    public String str;

    public static void main(String[] args) {

        new SubMain().doSomething();

    }

    public void doSomething() {

        System.out.println("Done.");

    }

}



class SubMain extends Main {

    @Override

    @SuppressWarnings("unchecked", "warning")

    public void doSomething() {

          java.util.ArrayList aList = new java.util.ArrayList();

          aList.add(new Integer(0));

        System.out.println("Done by SubMain.");

    }

}



当然，我们也完全可以写自己的注解。注解定义的语法是@interface关键字。J2SE(TM)
5.0支持三种形式的注解：不带参数的标记注解、带一个参数的注解和带多个参数的完整
注解。下面分别举例说明：



标记注解，类似@Deprecated，如：



@interface SomeEmptyAnnotation {}



单个参数的注解，如：



@interface MySingleElementAnnotation {

    String value();

}



以及多个参数的注解，如：



@interface MyAnnotationForMethods {

    int index();

    String info();

    String developer() default "Sean GAO";

}



我们可以看到，注解的定义跟interface的定义相当类似，我们还可以指定默认值。对于
这些注解，我们也可以为其添加注解，所谓“注解的注解”。比方讲，我们通常会使用
@Target指定注解的作用对象，以及用@Retention指定注解信息写入的级别，如源代码、
类文件等等。举个例子：



@Target(ElementType.METHOD)

@Retention(RetentionPolicy.SOURCE)

public @interface SignedMethod {

}



在使用时，我们需要在注解名称前面写上@，然后()中指定参数值，如：



@MyAnnotationForMethods (

        index = 1,

        info = "This is a method to test MyAnnotation.",

        developer = "Somebody else"

)

public void testMethod1() {

    // ...

}



注解的最大作用在于它在源代码的基础上增加了有用的信息，使得源代码的描述性更
强。这些信息可以被代码之外的工具识别，从而可以很方便的增加外部功能，以及减少
不必要的相关代码/文件维护。这里我想简单提一个超出J2SE(TM) 5.0范畴的话题：在未
来的EJB 3.0规范中会有相当多的对注解的应用，让我们预览一下将来的无状态会话bean
用注解来定义会是什么样子：



@Stateless public class BookShelfManagerBean {

    public void addBook(Book aBook) {

        // business logic goes here...

    }

    public Collection getAllBooks() {

        // business logic goes here...

    }

    // ...

}



我们甚至不用写任何接口和部署描述符，这些工作将完全由外部工具通过读取注解加上
反射来完成，这不是很好吗？





[C风格格式化输出]



Java总算也有类似C的printf()风格的方法了，方法名同样叫作printf()，这一特性依赖
于前边提到的可变长度参数。举个例子来说，我们现在可以写：



System.out.printf("%s has a value of %d.%n", someString, a);



怎么样，看上去还不错吧？需要注意的是Java为了支持多平台，新增了%n标示符，作为
对\n的补充。有关Java格式化输出的具体语法，请参考java.util.Formatter的API文
档。





[结语]



在这一篇介绍性的文章中，我们一起领略了J2SE 5.0带来的新的语言元素，不知道大家
是否也跟笔者一样，感受到了这些新特性在提高我们的开发效率上所作的巨大努力。其
实不只是语言元素，J2SE(TM) 5.0的发布在其他很多方面都作了不小的改进，包括虚拟
机、新的API类库等等，性能和功能上都有大幅提升。



对于主要靠J2EE吃饭的朋友来讲，也许真正意义上要在工作中充分利用这些新的元素，
恐怕要等主流的J2EE服务器都支持J2EE(TM) 5.0的那一天了，对此我们充满期待。