从下面的信息可以清楚看到JbpmConfiguration类来自于D:/jbpm-starters-kit-3.1/jbpm/build/jbpm-3.1.jar：

• OracleDataOperate、SqlserverDataOperate、MysqlDataOperate，分别代表Oracle、Sqlserver、Mysql这三种数据库的操作类。继承自AbstractDataOperate
• AbstractDataOperate是一个抽象类，包含了那些不同种类数据库都是一样代码的操作方法。继承自DataOperate
• DataOperate是上面说的数据操作类的统一接口，只有两个方法：取得一条记录、插入一条记录。
• DataOperateFactory是一个工厂方法，统一用它的方法来得到数据库操作类的实例。
• SampleClass是我们系统的某个功能模块的类。
• People是一个实体类，代表一条记录。三个字段　oid唯一标识符、name姓名、date生日。

• 从例子中我们可以看到什么是面向接口的编程方式。SampleClass使用数据操作类可以不必关心具体是那个类，只要是符合接口的都行
• 要实例？只须调用DataOperateFactory.getInstance()即可，其它的交于DataOperateFactory这个工厂来做吧，使用端什么都不用关心。
• 我们要支持新的数据库类型，只须要象OracelDataOperate那样，再写一个继承AbstractDataOperate的类即可，比如SysbaseDataOperate。然后到DataOperateFactory中加入相应代码即可。
• 如果我们想要可配置性更高，可以用privatestaticint dataType = MYSQL;中的值设置到一个文本文件中。

文/陈刚 from www.chengang.com.cn

一、前言

　　我这个AdminConsole项目是用Java Web Start（简称JWS）来让用户访问的，后来在用户登录部份用到了JAAS，而JAAS有一个登录配置文件的设定。过去，我一直是在Eclipse的Run里做设置“-Djava.security.auth.login.config=D:\wxxr\login.config”，如下图：

　　但这只是权宜之计，在将项目从本地以JWS发布到服务器就会碰到两个问题：（1）为了灵活，不能引用绝对地址的（2）在JWS中怎么设定对login.config的引用。

　　JAAS中对配置文件login.config的引用，主要有两种方法：
（1）动态配置：“-Djava.security.auth.login.config=D:\wxxr\login.config”。它其实是java.exe的一个参数，你可以像我一样在Eclipse的run里设置，也可以在命令行运行程序的方式中指定：c:\jdk\bin\java -Djava.security.auth.login.config=D:\wxxr\login.config -jar.......。
（2）在程序里静态配置：System.setProperty("java.security.auth.login.config", "D:\wxxr\login.config");

二、JWS中对JAAS动态配置的方法

　　在JWS中，如果你想动态配置的，则在JWS的jnlp文件里设置如下：
 <resources>
  <j2se version="1.4+" href="http://java.sun.com/products/autodl/j2se"  java-vm-args="-Djava.security.auth.login.config=D:\wxxr\login.config" />
　........  
 </resources>

或者

 <resources>
  <j2se version="1.4+" href="http://java.sun.com/products/autodl/j2se" />
  <property name="java.security.auth.login.config" value="D:\wxxr\login.config"/>
　........  
 </resources>

　　上面的设置有一个关键问题：对login.config引用的是绝对地址，这个地址不是指向服务器端的地址，而是客户端的地址。这也就要求客户在D:\wxxr\目录含有login.config文件，显然我们不能对客户有这种麻烦要求（最好就是客户什么都不用做，这也是JWS的存在的价值和目的）。
　　因此这里还有一个变通的方法：把“D:\wxxr\login.config”改成“http://your_website:8080/adminconsole/login.config”，这样就会去网上定位login.config，而不必再把login.config安装在客户端里了。


三、JWS中对JAAS静态配置的方法

　　在上面的用web url的方法中还是有一点缺陷，login.config将是可以被其他客户轻易看到的，安全性不高。而且服务器的网站名变了以后，还得相应修改jnlp文件。所以我们不妨考虑一下静态配置的方法，用静态配置方法之后，就不用在jnlp文件里配置了，少了不了麻烦。

第一种：

说明：
（1）BasicServiceImpl是JDK's javaws.jar包中的类（jdk\jre\javaws\javaws.jar）。
（2）BasicServiceImpl.getInstance().getCodeBase()得到的值是“http://your_website:8080/adminconsole/”，这个还是和前面web url其实一样，只不过它是动态获得web url。至于如何获得服务器的路径的那种，对于普通的java application我没研究过，我只试过下面eclipse RCP的。
（3）你只需要保证http://your_website:8080/adminconsole/login.config　能访问到login.config文件即可。

第二种：在Eclipse RCP程序中设置的方法

　　path的值有点怪，是“bundleentry://3/properties/login.config”。properties/login.config在服务器上的位置如下图：

　　注：Eclipse RCP要装在JWS上，还得用一个开源软件WebRCP：http://sourceforge.net/projects/webrcp。此开源软件简单易用，连文档都不用看。它提供的webrcp-tutorial，本身就是一个RCP使用webrcp的例子，你只需要参照archives\tutorial.zip的目录结构将自己的RCP项目打包，然后用自己项目的zip替换掉archives\tutorial.zip即可。如果你想换一个zip名字，则需要修改tutorial.jsp文件（其实也是一个jnlp）中的“<property name=....>”相应的几项。


参考资料：
http://forum.java.sun.com/thread.jspa?threadID=612861&tstart=300
http://forum.java.sun.com/thread.jspa?threadID=621588&messageID=3523625

　　最近由于工作关系，老大嘱咐我看一下Java Web Start。以前安装JDK时，会在“开始”菜单加一个快捷菜单“Java Web Start”，也不知是做什么用的，我一般都是删除。今天从网上查了一下资料，不看不知道，一看吓一跳，觉得这JWS（Java Web Start简称）很象传说中的“服务器端小程序下载运行”。而且JWS很早就有了，我看有些文章资料已经是2002年发的，自己竟然全然不知它的存在，实在是愚昧呀。

1.  JWS有什么用

　　B/S风行的一个很大原因就是它有部署方便的优势，这是C/S的Application所无法比拟的。现在，JWS让用户可以下载服务器端的Java Application到本机运行，并且没有安装、配置等繁琐的操作。SUN网站上有Demo，大家可以体验一下效果：http://java.sun.com/products/javawebstart/demos.html  。

2.  JWS的运行原理

　　浏览器的运行Java Applica ton的链接指向的不是程序本身，而是一个*.jnlp文件，这个文件包含了Java Application的一些配置信息。然后JWS解读这个文件的信息，将服务器端的Java Application下载到本机上，并运行。

　　当然第一次运行程序时，由于要下载所以速度会稍微慢一些，不过第二次运行时，JWS会自动去服务器上检查是否有新的程序版本发布，如果没有就会直接运行本机已经下载的程序，这就和运行本机Java Application没什么区别了。运行程序之初，JWS还会提示你是否创建一个相应的快捷菜单。

　　程序下载到本机的默认位置是：“C:\Documents and Settings\admin\Application Data\Sun\Java\Deployment\javaws\cache\indirect\indirect12423.ind”，你可以在本机的“JWS应用程序管理器”的里重新设置此存放目录。

　　JWS无疑要比Applet的应用范围更广（据说还得过＊＊的最佳创意奖），它对于布署一些小型的程序应用是非常方便的，但我以为现在还主要适用于局域网。因为一个程序一般约有几十M，如果是Internet用户第一次的下载速度会很慢。

3.  安全性问题

　　但和Applet一样，JWS也面临安全性问题，默认情况下JWS对本机磁盘和本地网络的访问是有限制的。如果该程序要越权访问，这时会弹出一个警告框（类似于ActivX的数字签名），用户可以自已决定是否信任该软件，而对其放开限制。

4.  JWS的优缺点

　　JWS的优点就是让程序的布署更简单，而且用户端的应用可以时刻保持和服务器端的最新版本同步，这为升级版本提供了很大的方便。缺点也是明显的，由于要运行应用必须一次下载所有的程序文件（JWS的jnlp配置文件有个lazy选项，但作用不明显），所以第一次下载速度很慢，不适用于互联网。从这一点来看B/S形式的应用还是有优势的。

5.  参考资料

http://www.chinaitlab.com/www/news/article_show.asp?id=25239
http://blog.csdn.net/emag_java/archive/2005/01/13/252047.aspx 

Java Web Start实例

1、示例说明

　　由于本BLOG现主要以Eclipse和SWT为内容，所以Java Web Start（简称JWS）也以一个SWT应用程序来做为示例。本文用＜Eclipse从入门到精通＞书中打包一章的打包结果为示例，该示例为一个SWT/JFace程序，其打包后的文件结构如下：

说明： 

• myswt是主包，里面含有自己写的程序代码
• swt-win32-3063.dll是本地化文件
• lib子目录下还有三个jar文件：jface.jar、runtime.jar、swt.jar，这三个文件是SWT程序的支持库

　　如果是在本地运行此程序，双击myswt.jar即可（要求Windows中jar格式的文件默认用javaw.exe打开，如下图所示：

　　现在我们要将这个程序用JWS部署到服务器端，然后编写一个网页，让用户单击网页上的链接就可以下载该SWT程序并运行。

2、准备工作

本人的开发环境为：WinodwsXP SP2 ＋ JDK1.4.2 ＋ Tomcat 5.0.28
（1）首先得先安装Tomcat，这一步的操作方法本文省略
（2）在Tomcat的webapps\ROOT路径下创建一个“myswt”目录。在我的电脑上，其绝对路径如下：E:\Program Files\Apache Software Foundation\Tomcat 5.0\webapps\ROOT\myswt。
（3）将前面所述的SWT程序的文件复制到webapps\ROOT\myswt目录中。

3、生成证书

创建一个批处理文件：key.bat

c:\jdk\bin\keytool -genkey -keystore myKeystore -alias myself
c:\jdk\bin\keytool -list -keystore myKeystore
pause

说明：

• keytool是JDK自带的一个工具，用于数字签名。在我的电脑，它是位于c:\jdk\bin\路径下，由于我没有设置环境变量path，所以在批处理文件中硬性指定keytool的路径。如果是自己用或者公司内部用，象本文这样用keytool生成一个自签名的证书也就可以了。但如果你想让签名更正式一些，以获得其他用户的信任，最好去认证中心（如 Thawte 或 VeriSign）获取一个证书。
• 第一句将生成一个证书，文件名：myKeystore
• 第二句是列出密钥证书中的所有入口。（这一句是可选的，只是为了显示出来看一下，不要也行）
• 最后一句是暂停pause，以便批处理完成后，我们可以回顾一下全过程。

运行批处理key.bat后的全部输入过程如下图所示：

4、用证用为应用程序签名

（1）因为签名只认jar包，所以先将swt-win32-3063.dll文件用WinRAR或c:\jdk\bin\jar打一个jar包(swt-win32-3063.jar)。客户端下载后，会自动解开此包，将swt-win32-3063.dll还原到客户端。

注意：如果你用WinRAR打包，在压缩时必须选ZIP格式，不能选RAR格式。

（2）创建一个用于签名的批处理文件：jarsigner.bat，其内容如下：

c:\jdk\bin\jarsigner -keystore myKeystore myswt.jar myself
c:\jdk\bin\jarsigner -keystore myKeystore lib\jface.jar myself
c:\jdk\bin\jarsigner -keystore myKeystore lib\runtime.jar myself
c:\jdk\bin\jarsigner -keystore myKeystore lib\swt.jar myself
c:\jdk\bin\jarsigner -keystore myKeystore swt-win32-3063.jar myself
pause

5、创建jnlp文件

<?xml version="1.0" encoding="GBK"?>
<jnlp codebase="http://localhost:8080/myswt">
 <information>
  <title>子在川曰(http://blog.csdn.net/glchengang)</title>
  <vendor>陈刚</vendor>
  <offline-allowed/>
 </information>
 <security>
  <all-permissions/>
 </security>
 <resources>
  <j2se version="1.4+"/>
  <jar href="myswt.jar"/>
  <jar href="lib/jface.jar"/>
  <jar href="lib/runtime.jar"/>
  <jar href="lib/swt.jar"/>
  <nativelib href="swt-win32-3063.jar"/>
 </resources>
 <application-desc main-class="jface.dialog.wizard.WizardDialog1"/>
</jnlp>

• encoding="GBK"  本文选择了GBK，一般来说应该用UTF-8。我在这里之所以选择GBK字符集，主要是为了演示示例方便，如果是正式应用，还是应该改为UTF-8。如果用UTF－8，则该文件的中文要转换成UNICODE码，否则实际运行时将显示乱码，你可以用c:\jdk\bin\native2ascii.exe来进行“汉字－＞UNICODE”的转换。
• codebase="http://localhost:8080/myswt" 本应用程序的URL
• <information>项，是一些显示信息，<title>、<vendor>都是必选的。<offline-allowed/>是可选的，它表示允许应用程序脱机运行（不和服务器联网）。
• <security>项是指开放用户本机的所有权限给应用程序，这一项会导致弹出一个数字签名对话框。
• <resources>列出了用户需要下载的资源。<j2se version="1.4+"/>是指，要求用户本机安装Java1.4以上版本。<nativelib>是指此包含有本地文件，这时JWS下载后会将此包解开。
• <application-desc>指定了程序的入口类，你也可以指定其他的入口类，它不受限制。jface.dialog.wizard.WizardDialog1是myswt.jar包中的一个向导式对话框，这是我自己编写的一个SWT程序。

（2）创建一个HTML网页，网页指向jnlp文件。我们给此HTML网页取名：test.html，其内容如下：

<A HREF="myswt.jnlp">启动</A>

6、最后效果

（1）最后的服务器的目录结构如下图所示：

（2）用浏览器浏览：http://localhost:8080/myswt/test.html

单击“启动”后出现下图，开始从服务器上下载SWT应用程序：

下载完成后，出现如下图，提示用户是否向应用程序开放本机所有权限（弹出这个对话框是由jnlp文件中的<security>项设置决定的）。

单击“启动”按钮，将运行程序，出现下图。（附注：这里没有弹出提示你添加快捷菜单的对话框）

7、其他注意事项

（1）如果单击网页的“启动”链接时，显示的是jnlp文件的内容，还非下载服务器的应用程序。这时你需要做如下检查：

•  在Windows中，jnlp格式的文件应该默认用javaw打开。如果你把它改变成了用记事本或其他程序打开，就也会出错。
• WEB服务器是否能否辨识jnlp、jar、class文件的格式。如果你是用Tomcat，可以打开conf目录的WEB.XML文件检查一下。一般来说，较新的WEB服务器都支持jnlp，如果Tomcat、WebLogic等（微软的IIS不支持Java，当然也不可能支持jnlp，我是这么想的没去测试过）。如果不支持，就在WEB服务器的配置文件里加上下面的内容。

<mime-mapping>
 <extension>class</extension>
 <mime-type>application/java</mime-type>
</mime-mapping>

<mime-mapping>
 <extension>jar</extension>
 <mime-type>application/java-archive</mime-type>
</mime-mapping>
 
<mime-mapping>
 <extension>jnlp</extension>
 <mime-type>application/x-java-jnlp-file</mime-type>
</mime-mapping>

（2）在使用Java Web Start的时候可能会出现"下载资源错误"，大致的出错信息如下：

JNLPException[category: Download Error : Exception:
   java.io.IOException:
   rename failed in cache : LaunchDesc: null ] at..... 

<application-desc main-class="XBFrame"/>
 <argument>-port</argument>
 <argument>1008</argument>  "注意-port和1008是两个参数，要分开写
</application-desc>

参考资料

作者简介

　　这是一个很体帖的改进。在JDK5.0以前我们常看到下面的代码。

        Vector v=new Vector();
        v.add(new Integer(1));

　　因为Vector.add只接受对象，而1不是对象，所以我们还得把整数１装箱到Integer对象里，真麻烦:(　。现在我们可以这样了，是不是方便许多呢？如下：

        Vector<Integer> v=new Vector<Integer>(1);
        v.add(1);

二、新的for循环

　　在前面讲枚举的时候已经用到了，再把进面的代码粘贴一次吧，如下：

        Color[] colors = Color.values();
        for (Color c : colors) {
            System.out.println("color value=" + c.getColorValue());
        }

　　注意：不要以为Color[]是数组，就以为for-each循环只适用于数组，对于集合（List、Set)一样可以的，如下：

        List<String> list = new ArrayList<String>();
        for (String str : list) {
            System.out.println(str);
        }

三、参数个数的可变性

　　参数的个数是可变的，如下代码中的test方法就是一个int型的可变参数，当然你可以将参数设成String、Object等。

public class Test {
    public static void main(String[] args) {
        test();
        test(1);
        test(2, 3, 4);
    }

    public static void test(int... ints) {
        for (int i : ints) {
            System.out.println(i);
        }
    }
}

四、静态引用

　　什么是静态引用，先看下面的代码：

package jdk5;
public class Model {
    public static void operate() {}
    public static String ABC;
}

Model类有一个静态方法operate和一个静态变量（必须是静态的），这是一个很普通的类。而下面的Test类就有些奇怪了：

package jdk5;

import static jdk5.Model.ABC;
import static jdk5.Model.operate;

public class Test {
    public static void test() {
        operate();
        String s = ABC;
    }
}

有那些奇怪的地方呢？

（１）import 后面多了一个static
（２）jdk5.Model后面多写了方法operate和变量ABC

　　有了上面奇怪的写法之后，以后在Test类中要使用import static的方法、变量就可以象本地方法和变量一样用了。

五、C风格格式化输出

　　以前我们在这里写代码：

    public static void main(String[] args) {
        int x = 10;
        int y = 20;
        int sum = x + y;
        System.out.printf(x + " + " + y + " = " + sum);
    }

　　在JDK5.0后，我们这样写代码：

    public static void main(String[] args) {
        int x = 10;
        int y = 20;
        int sum = x + y;
        System.out.printf("%d + %d = %d", x, y, sum);
    }

　　两段代码的效果都是一样的“10 + 20 = 30”，但第二种C风格的写法显示方便易读多了。

六、元数据（注解）

　　这是JDK5.0学XDoclt的，有了注解，以后我们可以不必写接口，EJB写起来会方便很多。EJB3.0要精简写法，注解要占一些功劳。

　　介绍一个常用的注解：@Override，示例如下：

public class Test extends ATest{
 
    @Override
    public void test() {
    }
}

　在方法前加了这个注解，就限定死了Test的这个方法一定要是覆盖自ATest的方法test，否则就会报错。比如你不心把方法test()写成了tesd()，编译时就会报错。另一个要注意的是@Override用于定义覆盖接口的方法，也就是说ATest必须是一个抽象类、普通类，但不能是接口。

   另一个常见到的注解是@Deprecated，表明该项（类、字段、方法）不再被推荐使用。不过我们自己一般很少用到这个注解。

　　好了，注解只讲这两个吧，也不必了解太多，知道个概念，以后用到的时候再说吧。关于注解，建议看看XDoclt，这是一个开源小工具，在项目开发中非常好用。

作者简介

陈刚，广西桂林人，著作有《Eclipse从入门到精通》
您可以通过其博客了解更多信息和文章：http://www.chengang.com.cn

文/陈刚 2005-11-09 

一、前言

　　泛型这个词在现在的JAVA挺时髦，光从字面上你是无法知道它代表些什么东东的，所以我们还是不要从字面去理解，而是从一些实例去了解它吧。

二、泛型之前的日子

　　ＪＤＫ１.4之前是没有泛型的概念的，所以我们才会有下面的代码:

        List list = new ArrayList();
        list.add("aaaa");
        list.add("bbbb");
        list.add("cccc");

        for (Iterator it = list.iterator(); it.hasNext();) {
            String str = (String) it.next();
            System.out.println(str);
        }

　　上面是一段很平常的代码，在一个List集合加入一些字符串，然后再用一个遍历循环把它打印出来。“String str = (String) it.next()”这一句我们可以看到List取出值都是Object，所以我们要得String型，还要做一个类型转换，真是麻烦。更麻烦的是list.add(Object obj)的参数是Object类型，所以如果我们一不小心把list.add("cccc");写成list.add(new Integer(76));程序在循环打印的类型转换中就会出错。

　　问题：我们能不能让add方法只认String型呢？
　　回答：可以！用JDK5.0的泛型。

三、泛型后的幸福生活

　　JAVA有了泛型后，就象十年的老光棍讨了老婆，那个好处自不待言。我们来看看上面的例子改成泛型的写法是怎么样的：

        List<String> list = new ArrayList<String>();
        list.add("aaaa");
        list.add("bbbb");
        list.add("cccc");

        for (Iterator<String> it = list.iterator(); it.hasNext();) {
            String str=it.next();
            System.out.println(str);
        }

　　看到差别了吗？泛型其实很简单，就是在定义类型的后面加上"<类型>"这样子的声明就行了，它主要还有以下差别：

• list.add方法只能接受String类型。list.add(new Integer(76))这样的语句不需要运行程序，在编译时就会检查通不过。
• it.next()的返回值不再是Object，而变成了String

　　当然我们其实在循环部份也可以象下面这么写，是不是简洁了很多呢 :-)

        List<String> list = new ArrayList<String>();
        list.add("aaaa");
        list.add("bbbb");
        list.add("cccc");

        for (String str : list) {
            System.out.println(str);
        }

　　当然需要说明的是，List不仅可以List<String>，也可以是List<Integer>等等其他任何类型。

四、更深入了解泛型

（１）层层推进的泛型声明

　　“List<List> list;”表示什么呢？就是只接收List型的参数，比如：

        List<List> list = new ArrayList<List>();
        list.add(new ArrayList());
        list.add(new Vector());
        list.add(new LinkedList());

　　这里要注意List是接口，ArrayList、Vector、LinkedList都是这一接口下的实现类。下面这个有点怪异了，“List<List<String>> list;”表示它只接受List型的参数，而且这种List型的参数又是只是只接受String型，有点层层推进的味道在里面了。

        List<List<String>> list = new ArrayList<List<String>>();
        list.add(new ArrayList<String>());
        list.add(new Vector<String>());
        list.add(new LinkedList<String>());

（２）使用泛型上限通通配符：extends

　　这里要着重强调一点：变量的泛型声明和方法的参数的泛型声明有很大差别。

　　变量声明成某类型，同时也可以接受它的子类。比如说Integer、Long、Float都是抽象类Number的子类，所以下面的代码一点问题也没有：

        List<Number> list = new ArrayList<Number>();
        list.add(new Integer(1));
        list.add(new Long(1));
        list.add(new Float(1.2));

　　但如果换成方法参数的泛型声明则要严格得多了：子类也是不行的。比如下面的代码就是错误的，因为printList参数只接受Number值的List，就是是Number子类的Integer值的List也不行。

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(new Integer(1));
        list.add(new Integer(2));
        printList(list);
    }
    
    private static void printList(List<Number> list){
        for (Number num : list) {
            System.out.println(num);
        }
    }

　上面代码修改的方法有两个，如下

修改方法一：改变量的泛型声明
　　将　List<Integer> list = new ArrayList<Integer>();
　　改为　List<Number> list = new ArrayList<Number>();

修改方法二：用界限通配符改方法参数的泛型声明
　　将　printList(List<Number> list)
　　改为　printList(List<? extends Number> list)
　　说明：extends 的含义就是表示参数可以接受Number型的子类。

（３）使用泛型下限通通配符：super

   　在上限就有下限，下限行就是super，用法和extends一样，含义则和extends相反。比如printList(List<? super Integer> list)表示参数可以接受Integer型及Integer型的超类，即Number了，当然也包括Object这个顶级类。

（４）配置符：？

　　？表示可以接受任何类型，不过我觉得它用得不多，因为printList(List<?> list)和printList(List list)的作用是一样的。

五、创建一个支持泛型的类

（１）创建一个泛型的类

public class Point<T> {
    T x;
    T y;

    public T getX() {
        return x;
    }

    public T getY() {
        return y;
    }

    public void setX(T x) {
        this.x = x;
    }

    public void setY(T y) {
        this.y = y;
    }
}

　　使用这个类的代码如下：

        Point<Integer> p = new Point<Integer>();
        p.setX(new Integer(1));
        p.setY(new Integer(2));
        
        Point<String> b = new Point<String>();
        b.setX("1");
        b.setY("2");

　　说明：在Point<T>的定义中，T并非关键字，你也可以这样定义Point<ABC>，当然一般还是写T吧，简单也规范。

（２）泛型类的继承与实现

　　java.util.Comparator类是JDK里用来排序的，其源代码如下：

package java.util;
public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
}

   一个实现此接口的类如下：

    public class MyComparator<T> implements Comparator<ObjectInstance> {
        public int compare(ObjectInstance o1, ObjectInstance o2) {
            String s1 = o1.getObjectName().getCanonicalName();
            String s2 = o2.getObjectName().getCanonicalName();
            return s1.compareToIgnoreCase(s2);
        }
    }

　　说明：ObjectInstance可能大家还太明白，这是我实际项目中的一段代码（关于ＪＭＸ的），ObjectInstance全称javax.management.ObjectInstance。MyComparator的使用代码如下：

六、最后的感言

　　JAVA有了泛型就象老光棍讨了老婆，好处大大的，但和女人一样麻烦也跟着来了：它的严格类型检查，使隐藏的ＢＵＧ更少。有些地方确实也使代码简洁了，有些地方却会使得代码更复杂。所以运用之妙在于是否用得适当，尽量把泛型往简单里用，别越搞越复杂了。 

参考资料

J2SE 5.0中的泛型　http://www.matrix.org.cn/resource/article/43/43634_java_generics.html

作者简介

陈刚，广西桂林人，著作有《Eclipse从入门到精通》
您可以通过其博客了解更多信息和文章：http://www.ChenGang.com.cn

文/陈刚 2005-11-09 

一、前言

　　JDK5.0出来有快一年了吧，泛泛的浏览过一些资料，不知道是文章写得生涩，还是我愚笨，总之是没太明白。反正所做的项目也没有用到，所以放在了一边。近来公司平台升级到JBOSS4和JDK5，看来要仔佃看它一看看。上网搜索了一些资料，花了两小时阅读，算明白了一些，好象也不是很难。现将心得和理解结集成文，以便后来者。

　　JDK5.0主要有哪些新特性呢？如下列表

• 泛型
• 增强的for循环
• 自动装箱和自动拆箱
• 类型安全的枚举
• 可变长度参数
• 静态引入
• 元数据（注解）
• C风格的格式化输出

　　本文先讲“类型安全的枚举”。

二、旧的历史

　　举个例：有一个如下的“花(flower)”类，它有一个颜色(color)属性，用int型来表示其颜色。

public class Flower {
    private int color;

    public void setColor(int color) {
        this.color = color;
    }
    
    public int getColor(){
        return color;
    }
}

　　这时一般我们会创建一个常量类，来存放颜色常量，如下：

public interface Color {
    int RED = 0;
    int BLACK = 1;
    int YELLOW = 2;
    int BLUE = 3;
    int WHITE = 4;
    int ORANGE = 5;
}

　　以后我们用的时候就可以这样：

public class Client {
    public static void main(String[] args) {
        Flower f = new Flower();
        f.setColor(Color.RED);
    }
}

  Color类就是一个我们自己来实现的枚举类，当然它并不是严格意义上的枚举类，而且JDK5.0之前还没有枚举。这时会出现一个问题：setColor参数是int型，那么也许用户会不小心用一个非法的int值赋进去，这样就可能产生BUG，如：f.setColor(100);显示100并非是我们设定中的颜色值。

　　在那本有名的java著作<<Effective java>> Joshua Bloch，用了专门的一章（第５章）来讨论这个问题，书中给出了一个比较严谨的解决方案，如下代码所示

（１）用Color类更改如下：

public class Color {
    private final int color;

    private Color(int color) {
        this.color = color;
    }

    public int getColorValue() {
        return color;
    }

    public static final Color RED = new Color(0);
    public static final Color BLACK = new Color(1);
    public static final Color YELLOW = new Color(2);
    public static final Color BLUE = new Color(3);
    public static final Color WHITE = new Color(4);
    public static final Color ORANGE = new Color(5);
}

（２）Flower类也要相应的更改，将int改为Color型。

public class Flower {
    private Color color;

    public void setColor(Color color) {
        this.color = color;
    }

    public Color getColor() {
        return color;
    }
}

（３）客户端Client不用修改。

　　这样Flower类的setColor方法就只接收Color，也不用担心用户不心传入非法的参数值了。

三、新的特性：JDK5.0枚举

（１）简单的例子

　　JDK5.0的枚举，正好可以解决上面我们讨论的问题，而且更简洁。还是用上面的代码做示例，只需要将Color类修改如下，Flower、Client都无法更改。

public enum Color {
    RED, BLACK, YELLOW, BLUE, WHITE, ORANGE
}

　很简单吧。接下来我们做更深一步的说明：

• 所有枚举类都是java.lang.Enum的子类（JDK内核自动将Color隐性继承自Enum）
• RED...ORANGE都是Color的实例对象

　上面的Color枚举类，功能好象还和以前的例子不完全一样，我们再次修改如下。

public enum Color {
    RED(0), BLACK(1), YELLOW(2), BLUE(3), WHITE(4), ORANGE(5);
    
    int color;
    Color(int color){
        this.color=color;
    }
    
    public int getColorValue(){
        return color;
    }
}

　　从这里我们可以看到枚举类是如何创建构造函数及方法的，有一些隐性的东西要说明一下：

• 枚举类的构造函数要求是private的，如果象例子里那样不加修饰符，则Java会自动给加上。但如果你想加上public则会报错。
• RED(0), BLACK(1)...等枚举值必须定义在前面，而且最后一个枚举值ORANGE(5);未尾用分号结束。

（２）在循环中使用枚举类

　　枚举类都有一个values方法可以得到它值的数组：Color[] colors=Color.values();而且枚举类都支持泛型（以后的文章会重点说到），所以我们可以这样来遍历这个数组：

        Color[] colors = Color.values();
        for (Color c : colors) {
            System.out.println("color value=" + c.getColorValue());
        }

更简洁的写法是这样：

        for (Color c : Color.values()) {
            System.out.println("color value=" + c.getColorValue());
        }

（３）在switch（分支）中使用枚举

　　如下代码示例，这里要注意将“case RED:”写成“case Color.RED:”是会报错的，因为JDK5.0可以自动根据“switch (color)”就判断入你要使用什么枚举类型了。从这里也可以看出JDK5.0确实为用户做了帖心的考虑，尽量让程序员少写代码，写更简单的代码。

        Color color = Color.RED;
        switch (color) {
        case RED:
            //process ... 
            break;
        case BLACK:
            //process ...
            break;
        case WHITE:
            //process ...
            break;
        default:
            //process ...
        }

（４）JDK5.0新增的集合：EnumMap 和EnumSet

　　给出两个例子，一切尽在不言中了。（说明：这两个例子用到了JDK5.0中泛型的知识）

        Map<Color, String> map = new EnumMap<Color, String>(Color.class);
        map.put(Color.RED, "红色");
        map.put(Color.BLACK, "黑色");
        map.put(Color.WHITE, "白色");
        
        for (Color c : Color.values()) {
            System.out.println(c + " chinese is: " + map.get(c));
        }

        Set all = EnumSet.allOf(Color.class);
        EnumSet warmColors = EnumSet.of(Color.RED, Color.YELLOW);
        Set notWarmColors = EnumSet.complementOf(warmColors);
        Set notBlack = EnumSet.range(Color.RED, Color.YELLOW);

四、参考资料

http://dev.yesky.com/451/2044451_1.shtml

五、作者简介

陈刚，广西桂林人，著作有《Eclipse从入门到精通》
您可以通过其博客了解更多信息和文章：http://www.ChenGang.com.cn