初学者如何开发出一个高质量的J2EE系统

板桥里人 http://www.jdon.com 2005/06/20

　　J2EE学习者越来越多，J2EE本身技术不断在发展，涌现出各种概念，本文章试图从一种容易理解的角度对这些概念向初学者进行解释，以便掌握学习J2EE学习方向。

　　首先我们需要知道Java和J2EE是两个不同概念，Java不只是指一种语言，已经代表与微软不同的另外一个巨大阵营，所以Java有时是指一种软件系统的流派，当然目前主要是.NET和Java两大主流体系。

　　J2EE可以说指Java在数据库信息系统上实现，数据库信息系统从早期的dBase、到Delphi/VB等C/S结构，发展到B/S（Browser浏览器/Server服务器）结构，而J2EE主要是指B/S结构的实现。

　　J2EE又是一种框架和标准，框架类似API、库的概念，但是要超出它们。如果需要详细了解框架，可先从设计模式开始学习。

　　J2EE是一个虚的大的概念，J2EE标准主要有三种子技术标准：WEB技术、EJB技术和JMS，谈到J2EE应该说最终要落实到这三个子概念上。

　　这三种技术的每个技术在应用时都涉及两个部分：容器部分和应用部分，Web容器也是指Jsp/Servlet容器，你如果要开发一个Web应用，无论是编译或运行，都必须要有Jsp/Servlet库或API支持（除了JDK/J2SE以外）。

　　Web技术中除了Jsp/Servlet技术外，还需要JavaBeans或Java Class实现一些功能或者包装携带数据，所以Web技术最初裸体简称为Jsp/Servlet+JavaBeans系统。

　　谈到JavaBeans技术，就涉及到组件构件技术（component），这是Java的核心基础部分，很多软件设计概念（设计模式）都是通过JavaBeans实现的。

　　JavaBeans不属于J2EE概念范畴中，如果一个JavaBeans对象被Web技术（也就是Jsp/Servlet）调用，那么JavaBeans就运行在J2EE的Web容器中；如果它被EJB调用，它就运行在EJB容器中。

　　EJB（企业JavaBeans）是普通JavaBeans的一种提升和规范，因为企业信息系统开发中需要一个可伸缩的性能和事务、安全机制，这样能保证企业系统平滑发展，而不是发展到一种规模重新更换一套软件系统。

　　至此，JavaBeans组件发展到EJB后，并不是说以前的那种JavaBeans形式就消失了，这就自然形成了两种JavaBeans技术：EJB和POJO，POJO完全不同于EJB概念，指的是普通JavaBeans，而且这个JavaBeans不依附某种框架，或者干脆可以说：这个JavaBeans是你为这个应用程序单独开发创建的。

　　J2EE应用系统开发工具有很多：如JBuilder、Eclipse等，这些IDE首先是Java开发工具，也就是说，它们首要基本功能是可以开发出JavaBeans或Java class，但是如果要开发出J2EE系统，就要落实到要么是Web技术或EJB技术，那么就有可能要一些专门模块功能(如eclipse需要lomboz插件)，最重要的是，因为J2EE系统区分为容器和应用两个部分，所以，在任何开发工具中开发J2EE都需要指定J2EE容器。

　　J2EE容器分为WEB容器和EJB容器，Tomcat/Resin是Web容器；JBoss是EJB容器+Web容器等，其中Web容器直接使用Tomcat实现的。所以你开发的Web应用程序可以在上面两种容器运行，而你开发的Web+EJB应用则只可以在JBoss服务器上运行，商业产品Websphere/Weblogic等和JBoss属于同一种性质。

　　J2EE容器也称为J2EE服务器，大部分时它们概念是一致的。

　　如果你的J2EE应用系统的数据库连接是通过JNDI获得，也就是说是从容器中获得，那么你的J2EE应用系统基本与数据库无关，如果你在你的J2EE应用系统耦合了数据库JDBC驱动的配置，那么你的J2EE应用系统就有数据库概念色彩，作为一个成熟需要推广的J2EE应用系统，不推荐和具体数据库耦合，当然这其中如何保证J2EE应用系统运行性能又是体现你的设计水平了。

　　衡量J2EE应用系统设计开发水平高低的标准就是：解耦性；你的应用系统各个功能是否能够彻底脱离？是否不相互依赖，也只有这样，才能体现可维护性、可拓展性的软件设计目标。

　　为了达到这个目的，诞生各种框架概念，J2EE框架标准将一个系统划分为WEB和EJB主要部分，当然我们有时不是以这个具体技术区分，而是从设计上抽象为表现层、服务层和持久层，这三个层次从一个高度将J2EE分离开来，实现解耦目的。

　　因此，我们实际编程中，也要将自己的功能向这三个层次上靠，做到大方向清楚，泾渭分明，但是没有技术上约束限制要做到这点是很不容易的，因此我们还是必须借助J2EE具体技术来实现，这时，你可以使用EJB规范实现服务层和持久层，Web技术实现表现层；

　　EJB为什么能将服务层从Jsp/Servlet手中分离出来，因为它对JavaBeans编码有强制的约束，现在有一种对JavaBeans弱约束，使用Ioc模式实现的（当然EJB 3.0也采取这种方式），在Ioc模式诞生前，一般都是通过工厂模式来对JavaBeans约束，形成一个服务层，这也是是Jive这样开源论坛设计原理之一。

　　由此，将服务层从表现层中分离出来目前有两种可选架构选择：管理普通JavaBeans（POJO）框架(如Spring、JdonFramework)以及管理EJB的EJB框架，因为EJB不只是框架，还是标准，而标准可以扩展发展，所以，这两种区别将来是可能模糊，被纳入同一个标准了。　但是，个人认为：标准制定是为某个目的服务的，总要牺牲一些换取另外一些，所以，这两种架构会长时间并存。

　　这两种架构分歧也曾经诞生一个新名词：完全POJO的系统也称为轻量级系统(lightweight)，其实这个名词本身就没有一个严格定义，更多是一个吸引人的招牌，轻量是指容易学习容易使用吗？按照这个定义，其实轻量Spring等系统并不容易学习；而且EJB 3.0（依然叫EJB）以后的系统是否可称为轻量级了呢？

　　前面谈了服务层框架，使用服务层框架可以将JavaBeans从Jsp/Servlet中分离出来，而使用表现层框架则可以将Jsp中剩余的JavaBeans完全分离，这部分JavaBeans主要负责显示相关，一般是通过标签库（taglib）实现，不同框架有不同自己的标签库，Struts是应用比较广泛的一种表现层框架。

　　这样，表现层和服务层的分离是通过两种框架达到目的，剩余的就是持久层框架了，通过持久层的框架将数据库存储从服务层中分离出来是其目的，持久层框架有两种方向：直接自己编写JDBC等SQL语句（如iBatis）；使用O/R Mapping技术实现的Hibernate和JDO技术；当然还有EJB中的实体Bean技术。

　　持久层框架目前呈现百花齐放，各有优缺点的现状，所以正如表现层框架一样，目前没有一个框架被指定为标准框架，当然，表现层框架现在又出来了一个JSF，它代表的页面组件概念是一个新的发展方向，但是复杂的实现让人有些忘而却步。

　　在所有这些J2EE技术中，虽然SUN公司发挥了很大的作用，不过总体来说：网络上有这样一个评价：SUN的理论天下无敌；SUN的产品用起来撞墙；对于初学者，特别是那些试图通过或已经通过SUN认证的初学者，赶快摆脱SUN的阴影，立即开溜，使用开源领域的产品来实现自己的应用系统。

　　最后，你的J2EE应用系统如果采取上面提到的表现层、服务层和持久层的框架实现，基本你也可以在无需深刻掌握设计模式的情况下开发出一个高质量的应用系统了。

　　还要注意的是: 开发出一个高质量的J2EE系统还需要正确的业务需求理解，那么域建模提供了一种比较切实可行的正确理解业务需求的方法，相关详细知识可从UML角度结合理解。

　　当然，如果你想设计自己的行业框架，那么第一步从设计模式开始吧，因为设计模式提供你一个实现JavaBeans或类之间解耦参考实现方法，当你学会了系统基本单元JavaBean或类之间解耦时，那么系统模块之间的解耦你就可能掌握，进而你就可以实现行业框架的提炼了，这又是另外一个发展方向了。

　　以上理念可以总结为一句话：
J2EE开发三件宝: Domain Model（域建模）、patterns（模式）和framework（框架）。

　　推荐一套高质量的J2EE开源系统： JPestore

原文地址：http://www.cnblogs.com/bjzhanghao/archive/2004/08/08/31262.aspx
        记得几年前汉化软件一般是用二进制编辑工具在编译后的文件中查找和替换英文单词，这个过程需要使用很多技巧，非常的麻烦。而现在，在开发时对应用程序进行国际化处理已经越来越成为一个必不可少的步骤了。例如这次我参与的项目是给台湾客户做的，他们要求英文和繁体中文两个版本，幸好我们使用的开发工具是Eclipse，利用它的国际化功能可以很方便的将写在代码里的字符串提出到独立的资源文件中，这里用一个简单的例子说明一下这个过程。

在Eclipse里建立一个名为nls-test的工程（也可以国际化已有工程），新建一个类NLSTest，内容如下：

public class NLSTest {
 public NLSTest() {
  String str1="Hello world!";
  System.out.println(str1);
 }
 public static void main(String[] args) {
  new NLSTest();
 }
}

现在，这个类的输出是在代码里写死的，如果要改变就必须修改代码然后重新编译。下面我们利用Eclipse解决这个问题。在导航器（Package Explorer）里右键单击这个文件，选择Source -> Externalize Strings，就会打开一个对话框，在这里列出了该类中尚未国际化的字符串，见下图。

图1 国际化向导第一步

单击每个字符串前面的小方块可以选择对该串1、进行国际化处理2、永不进行国际化处理3、这次不处理。我们选择要对这个字符串进行国际化处理，并把它的Key修改为比较好理解的名称hello，注意在对话框最上方可以指定一个通用的前缀，这个值会加在每个Key前面作为最终写在资源文件（扩展名是.properties）里的Key名称。好，按下一步继续。

在这里要指定properties文件的名称，如果需要的话要指定一个用于从properties文件中取资源的类，一般是XXXMessages的格式，再按下一步，会显示一个所作更改的确认列表，确认后按Finish按钮完成向导。

可以看到Eclipse为我们生成了NLSTestMessages.java和NLSTest.properties，打开后者会看到里面只有这么一句：

NLSTest.hello=Hello world!

而前者NLSTestMessages的作用是根据参数Key从后者取对应的字符串值，看一看现在的NLSTest.java就知道了，它的内容现在是这样的（只列出构造方法，main方法同上）：

 public NLSTest() {
  String str1=NLSTestMessages.getString("NLSTest.hello"); //$NON-NLS-1$
  System.out.println(str1);
 }

后面的注释是Eclipse自己用的，标有这个注释的字符串在国际化将被忽略。注释中的数字1表示要忽略的是该行中第一个字符串，如果一行语句里有多个字符串被忽略，将会有多个这样的注释，但数字会各不相同，像这样：

 //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ 

好了，现在这个类的国际化处理就算完成了。要想让这个类可以根据用户所在地区输出不同语言的结果，可以在NLSTest.properties同一目录下创建名为NLSTest_XX.properties的文件，其中XX表示国家名称，例如中国是zh_CN或tw_CN，法国是FR等等。新创建的文件里也要有和原来文件相同的名值对，但值是不同语言的，NLSTestMessages类会根据用户机器的地区设置值自动从不同的资源文件里取值，这样就达到了国际化的目的。要在自己的机器上测试运行结果，可以在Eclipse的运行设置里面加上这样的参数：-nl tw_CN，这样就不用费力气设置区域了。

国际化的原理很简单，Eclipse提供的这个功能使国际化变得更容易了。不过关于国际化还有一些细节问题，包括对含参数资源的处理，字符编码处理等等，下篇将对它们进行讨论。

1、log4j已经被移植到C, C++, C#, Perl, Python, Ruby, Eiffel 几种语言。
2、log4j有三种主要的组件：记录器,存放器,布局
3、记录器（记录器可不关心log数据存放的事哟）
　　log4j允许程序员定义多个记录器，每个记录器有自己的名字，记录器之间通过名字来表明隶属关系（或家族关系）。列如，记录器a.b,与记录器a.b.c之间是父子关系，而记录器a与a.b.c之间是祖先与后代的关系，父子关系是祖先与后代关系的特例。通过这种关系，可以描述不同记录器之间的逻辑关系。
　　有一个记录器叫根记录器，它永远存在，且不能通过名字检索或引用，可以通过Logger.getRootLogger()方法取得它，而一般记录器通过Logger.getLogger(String name)方法。下面是Logger类的基本方法。

　　每一条要输出的log信息，也有一个级别值。
　　前面的Logger类中，就预定义了 DEBUG, INFO, WARN, ERROR ，FATAL几种级别，由于与方法绑定，让人易产生误解，其实这几个方法只不过表明了要记录的log信息的级别。当调用log()方法时，log信息的级别就需要在通过参数明确指定。
　　如果一条log信息的级别，大于等于记录器的级别值，那么记录器就会记录它。如果你觉得难以理解，可参考下例。

   // get a logger instance named "com.foo"
   Logger  logger = Logger.getLogger("com.foo");

   // Now set its level. Normally you do not need to set the
   // level of a logger programmatically. This is usually done
   // in configuration files.
   logger.setLevel(Level.INFO);

   Logger barlogger = Logger.getLogger("com.foo.Bar");

   // This request is enabled, because WARN >= INFO.
   logger.warn("Low fuel level.");

   // This request is disabled, because DEBUG < INFO.
   logger.debug("Starting search for nearest gas station.");

   // The logger instance barlogger, named "com.foo.Bar",
   // will inherit its level from the logger named
   // "com.foo" Thus, the following request is enabled
   // because INFO >= INFO.
   barlogger.info("Located nearest gas station.");

   // This request is disabled, because DEBUG < INFO.
   barlogger.debug("Exiting gas station search");

　　有几个有趣的情况，一是当一个记录器实例化后，再一次用相同的名字调用getLogger()会返回对它的引用，这非常有利于用同一个记录器在不同代码或类中记录log信息，另一个是与自然界中祖先先于后代出现不同，一个记录器的祖先可以比后代记录出现的晚，但会自动根据名字之间的关系建立这种家族关系。

4、存放器
　　在log4j中，log信息通过存放器输出到目的地。支持的存放器有console, files, GUI components, remote socket servers, JMS, NT Event Loggers, remote UNIX Syslog daemons。通过file存放器，log信息可以被输出到不同的文件中（即不同的目的地）。log信息可被异步存放。
　　一个记录器可以有多个存放器，可以通过方法addAppender来增加存放器。一条blog信息如果可被这个记录器处理，则记录器会把这条信息送往每个它所拥有的存放器。
　　每个记录器有一个继承开关,其开关决定记录器是/否继承其父记录器的存放器，注意，如果继承则只继承其父记录器，而不考虑更远的祖先的情况。参考下表：

记录器	增加的存放器	继承的存放器	输出的目的地	备注
root	A1	not applicable	A1	The root logger is anonymous but can be accessed with the Logger.getRootLogger() method. There is no default appender attached to root.
x	A-x1, A-x2	TRUE	A1, A-x1, A-x2	Appenders of "x" and root.
x.y	none	TRUE	A1, A-x1, A-x2	Appenders of "x" and root.
x.y.z	A-xyz1	TRUE	A1, A-x1, A-x2, A-xyz1	Appenders in "x.y.z", "x" and root.
security	A-sec	FALSE	A-sec	No appender accumulation since the additivity flag is set to false.
security.access	none	TRUE	A-sec	Only appenders of "security" because the additivity flag in "security" is set to false.

　　
　　
5、布局
　　布局负责格式化输出的log信息。log4j的PatternLayout可以让程序以类似C语言printf的格式化模板来定义格式。

6、log4j可据程序员制定的标准自动提供一些log信息，这对那类需要频繁log的对象的情况很帮助。对象的自动log，具有继承性.

参考文献：
1、log4j--新的日志操作方法，scriptskychen ，http://www.cn-java.com/target/news.php?news_id=2590

苹果 2005-07-29 17:05 发表评论

]]>

在本文的上篇里，介绍了使用Eclipse的国际化工具对程序中的字符串进行外向化处理（Extenalize），可以看出步骤是十分简单的。实在是很喜欢Eclipse这样的工具，它可以为你做很多事情，干净漂亮，但绝不会在未经你同意的情况下做任何动作，所谓“利器”也！

现在说说在资源中含有参数的情况怎样处理。比如在对话框中要显示信息：“帐户目前还有 900 元，截止日期为 2004-9-1，谢谢！”，因为中间的数字和日期是动态的，所以不能直接放在资源文件中。但是请放心，大可不必为这条信息指定三个资源（被数字和日期分开的三个字符串），可以在资源文件（.properties）中指定资源为这个样子：

my.resource.key=帐户目前还有 {0} 元，截止日期为 {1}，谢谢！

其中{0}和{1}表示将替换为动态的值，然后在程序里写：

Float amount=;
Date dt=;
String msg=MessageFormat.format(Messages.getString("my.resource.key"), new Object[]{amount,dt});

这样，msg变量里就是动态生成的提示信息了。你很可能希望对日期进行格式化处理，要实现这个功能也很简单，只要稍微修改一下资源，如下：

帐户目前还有 {0} 元，截止日期为 {1,date,yyyy-MM-dd}，谢谢！

确实简单吧，不知道你用没用过这个写法，我是在PPP项目中才第一次使用的，所以赶紧介绍一下了，呵呵。

接下来的问题是编码，资源文件写为英文是没有问题的，可以正常显示，但汉字是不能直接写在资源文件里的，要转换为unicode才可以。jdk本身提供了native2ascii工具，可以实现这个功能，但用命令行总是不太方便，虽然也有人很喜欢使用命令行的感觉……如果你愿意Eclipse为你服务，大可以使用我下面介绍的两个插件，利用它们，你根本不需要显式转换编码这一步了。

第一个是Properties Editor，好象是日本人写的，安装后它会与扩展名为.properties的文件相关联，使用它打开资源文件，可以在本地语言与unicode视图之间切换，一般情况下编辑本地语言就可以了，保存时会自动转换为unicode。当需要查找某个资源（值）并修改时这个编辑器非常方便，例如想把资源里所有“你好”改为“您好”，如果面对的是一堆unicode码还真是头疼。安装这个插件需要2.1.1版本以上的Eclipse。

另一个我们在项目中经常使用的插件叫……我还真不知道它全名叫什么，在我这里的打包文件名是“29 Localization Editor”，它是一个非常方便的国际化翻译工具。用它打开扩展名为.properties的文件后，可以新建key，或者新建语言，你要做的只是在表格中把尚未翻译成新语言的资源值填下而已，可以选择只显示未翻译的条目或是全部条目。不过很对不起，我还没找到网上的下载地址，如果需要请和我联系吧。

图1 Localization Editor使用界面

好了，关于Eclipse的国际化先介绍到这里了。如果你的应用程序是Eclipse插件，还可以更进一步：把资源文件打成语言包。关于这种方式（Fragment）的介绍，以后有时间再写吧。

    原文地址：http://meta.blogchina.com/812188.html                                  

我感兴趣的问题实际上就是Ontology based metadata services for information retrieval. 实际上是开发一个或一组智能代理，利用Semantic Web services架构解决异构系统的情报检索互操作问题。前提条件是一定的Semantic Web services架构。首先必须对这个概念解释清楚。这是个很热门的话题了实际上，一篇经典的文章见（2001年的文章，稍早一些，还没有DAML-S）：http://www.daml.org/services/ieee01-KSL.pdf，一个作者是越南人，第三作者是个中国留学生，都很年轻啊！

以下主要来自（Katia Sycara, Massimo Paolucci, Anupriya Ankolekar, Naveen Srinivasan, "Automated discovery, interaction and composition of Semantic Web services"）

Web services 利用自主的代理在分布的环境中实现自动的"按需"服务，Semantic Web提供服务描述和服务接口的语义支持，目前这方面的标准正在逐步建立起来，然而多个Web service之间的协调和语义一致性是一个关键问题，目前BPEL4WS 和WSCI在这方面作了一些探索，然而最可能的途径是通过DAML-S提供解决框架。

组合多个Web services可以分为三方面的问题：

1. "计划"Web服务之间的交互以及其提供的功能如何整合；
2. "发现"Web服务实现的的任务；
3. 对Web服务之间的"交互"进行有效的管理。

这三个方面是交织在一起的，计划决定了如何去发现Web服务的类型，却依赖于Web服务的实现。同样，Web服务的交互过程依赖于计划的实施，计划本身又依赖于对交互的需求。

揭示一个Web服务，系统必须提供对于Web服务所能实现功能和能力的描述机制，并且能够识别和比较不同Web服务的功能和能力的异同。另一个挑战是系统还必须支持对不同Web服务的交互的支持。

也就是说需要从语义和语法两个方面提供互操作性，而不是仅仅是目前考虑的重点——从语法上制定协议标准（例如SOAP和WSDL，利用XSD展现消息数据的结构）。语法的互操作性仅仅提供了消息交换的结构，没有提供消息内容的解释。UDDI仅仅是关于Web服务的信息库，并不包含Web服务能力的揭示。WSCI和BPEL4WS描述了多个Web服务可以组合在一起成为一个更复杂的Web服务，但是其重点放在语法的规定上，因此并不支持自动的Web服务的组合。

语义互操作因此成为Web服务协同组合的关键问题。它必须：

1. 表达和支持Web服务的任务实现（例如网上卖书或者信用卡认证等），以便通过对于Web服务功能清楚的描述和广告而实现自动发现；
2. 表达和支持业务关系和规则（Business relations and rules）；
3. 表达和支持消息排序（message ordering）；
4. 理解消息的语义；
5. 表达和支持使用特定Web服务的前提条件以及激活服务的效果；
6. 允许Web服务组合成为更为复杂的服务。

Web服务可以直接在语义Web基础上直接建立，后者为Web提供了内容语义，能够被代理或者其他服务获取，代理能够通过严格定义的语义内容和规则进行推理，由本体提供的概念模型能够很好地解释Web网页的内容。从这一点来看，语义Web为Web服务提供了其所需得的语义互操作的基础，提供了形式化的语言和本体，用以支持服务描述、消息内容的理解、业务规则，并提供了不同本体之间的联系。语义Web和Web服务互相促进：前者使Web成为一个庞大的机读数据库，后者提供机器自动使用这些数据的工具。

由此可以认为，"语义Web服务"是语义元数据、本体、形式化工具和Web服务架构的集成，是基于良好定义的语言进行语义描述的Web服务(A Semantic Web service is a Web Service whose description is in a language that has well-defined semantics)。

因此，网络计算的不确定性得到了最大程度的消除，Web服务的发现、选择、组合、沟通、激活、监测、管理、恢复和补偿都得到了最大程度的自动化和实现。特别低，语义Web服务依赖语义Web描述：

1. 消息交换的内容；
2. 消息交换的顺序；
3. 消息交换的状态变化。

结果为不同服务的无缝互操作提供了基础。

利用语义Web描述Web服务有很多具体内容，包括描述Web服务的许多附加属性，例如服务质量、安全性约束等，可能最重要的是在Web服务的运行过程中的状态描述，包括其输入和前提条件，以及输出和结果等，这些是对于其功能和能力描述所必需的。

文章的第二部分讨论了DAML-S对于发现和激活语义Web服务的作用，并进一步讨论了Web服务发现的不同方法和DAML-S处理模型的形式语义。第三部分集中讨论DAML-S怎样用于Web服务能力的发现，怎样在UDDI注册系统的基础上更进一步。在第四部分介绍了DAML-S虚拟机，主要用于第二部分介绍的"DAML-S处理模型"形式语义的处理。第五部分提供了DAML-S虚拟机运行效果的评价，我们可以看到其运行并不频繁。第六部分描述了一个具体的利用DAML-S组合服务的应用。第七部分是结论。

（语义Web服务图示及说明）。

服务描述一般包括三方面内容：服务能力描述；非功能性静态参数（元数据）；对该项服务负责的服务实体的描述。

服务能力描述：对于符合一定前提条件的Web服务输入产生一定的输出（返回消息），以及其间的副产品。例如一个付费新闻服务需要一个日期和信用卡帐号的输入，然后判断是否符合日期和信用卡的有效性以及信用卡没有被过度使用（超出信用额度的透支）的前提条件，所产生的输出是提交用户一个满足其日期请求的新闻网址，以及从信用卡中扣除相应的服务费用，其中可能会有非功能性静态参数（元数据）参与整个过程，例如对于新闻质量、收费标准以及新闻类别的选者和控制等。

处理过程和服务概要提供了描述Web服务的两个方面：服务概要描述服务内容和能力，而处理过程描述如何实现服务。例如Amazon的Web服务的概要描述了该网站的售书功能，而服务过程则必须详细描述为了实现卖书的过程，请求者必须首先查到他所需要的书，提供支付信息，并提供发货地址等。

public class HelloWorld {
  public static void main(String[] args) {
    System.out.println("Hello Java World!");
  }
 }

[JAVA100例]002、Java流程控制

public class flowDemo{    public static void main(String[] arges){      int iPara1,iPara2,iEnd;      if(arges.length!=3)      {        System.out.println("USE :java flowDome parameter1 parameter2 circle");        System.out.println("parameter1 : 比较条件1，数字类型");        System.out.println("parameter2 : 比较条件2，数字类型");        System.out.println("circle ：循环次数");        System.out.println("ego:java flowDome 1 2 5");        return;      }else{        iPara1 = Integer.parseInt(arges[0]);        iPara2 = Integer.parseInt(arges[1]);        iEnd = Integer.parseInt(arges[2]);      }      //if语句      if(iPara2>iPara1)      {       System.out.println("if 条件满足！");       System.out.println("第2个数比第1个数大！");      }      else      {       System.out.println("if 条件不满足！");       System.out.println("第2个数比第1个数小！");      }      //for循环操作      for(int i=0;i<iEnd;i++)      {        System.out.println("这是for 第"+i+"次循环");      }      //while循环操作      int i=0;      while(i<iEnd)      {       System.out.println("这是while 第"+i+"次循环");       i++;      }      //do-while循环操作      int j=0;      do      {       System.out.println("这是do-while 第"+j+"次循环");       j++;      }while(j<iEnd);    }  }

[JAVA100例]003、数组数据操作

public class  myArray{    //初始化数组变量    char[] cNum = {'1','2','3','4','5','6','7','8','9','0'};    char[] cStr = {'a','b','c','d','e','f','g','h',                   'i','j','k','l','m','n','o','p',                   'q','r','s','t','u','v','w','x','y','z'};    int[] iMonth = {31,28,31,30,31,30,31,31,30,31,30,31};    String[] sMail = {"@","."}; /**  *<br>方法说明：校验电子邮件  *<br>输入参数：String sPara 被校验的电子邮件字符  *<br>返回类型：boolean 如果校验的格式符合电子邮件格式返回true；否则返回false  */      public boolean isMail(String sPara){     for(int i=0;i<sMail.length;i++){       if(sPara.indexOf(sMail[i])==-1)         return false;          }     return true;    } /**  *<br>方法说明：判断是否是数字  *<br>输入参数：String sPara。 需要判断的字符串  *<br>返回类型：boolean。如果都是数字类型，返回true；否则返回false  */      public boolean isNumber(String sPara){      int iPLength = sPara.length();      for(int i=0;i<iPLength;i++){       char cTemp = sPara.charAt(i);       boolean bTemp = false;       for(int j=0;j<cNum.length;j++){         if(cTemp==cNum[j]){           bTemp = true;           break;         }       }       if(!bTemp) return false;      }     return true;    } /**  *<br>方法说明：判断是否都是英文字符  *<br>输入参数：String sPara。要检查的字符  *<br>返回类型：boolean。如果都是字符返回true；反之为false  */      public boolean isString(String sPara){      int iPLength = sPara.length();      for(int i=0;i<iPLength;i++){       char cTemp = sPara.charAt(i);       boolean bTemp = false;       for(int j=0;j<cStr.length;j++){         if(cTemp==cStr[j]){           bTemp = true;           break;         }       }       if(!bTemp) return false;      }     return true;    } /**  *<br>方法说明：判断是否是闰年  *<br>输入参数：int iPara。要判断的年份  *<br>返回类型：boolean。如果是闰年返回true，否则返回false  */      public boolean chickDay(int iPara){      return iPara%100==0&&iPara%4==0;    } /**  *<br>方法说明：检查日期格式是否正确  *<br>输入参数：String sPara。要检查的日期字符  *<br>返回类型：int。0 日期格式正确，-1 月或这日不合要求， -2 年月日格式不正确  */    public int chickData(String sPara){     boolean bTemp = false;     //所输入日期长度不正确     if(sPara.length()!=10) return -2;     //获取年     String sYear = sPara.substring(0,4);     //判断年是否为数字     if(!isNumber(sYear)) return -2;     //获取月份     String sMonth = sPara.substring(5,7);     //判断月份是否为数字     if(!isNumber(sMonth)) return -2;     //获取日     String sDay = sPara.substring(8,10);     //判断日是否为数字     if(!isNumber(sDay)) return -2;     //将年、月、日转换为数字     int iYear = Integer.parseInt(sYear);     int iMon = Integer.parseInt(sMonth);     int iDay = Integer.parseInt(sDay);     if(iMon>12) return -1;     //闰年二月处理     if(iMon==2&&chickDay(iYear)){       if(iDay>29) return 2;     }else{       if(iDay>iMonth[iMon-1]) return -1;     }     return 0;    } /**  *<br>方法说明：主方法，测试用  *<br>输入参数：  *<br>返回类型：  */    public static void main(String[] arges){      myArray mA = new myArray();      //校验邮件地址      boolean bMail = mA.isMail("tom@163.com");      System.out.println("1 bMail is "+bMail);      bMail = mA.isMail("tom@163com");      System.out.println("2 bMail is "+bMail);      //演示是否是数字      boolean bIsNum = mA.isNumber("1234");      System.out.println("1：bIsNum="+bIsNum);      bIsNum = mA.isNumber("123r4");      System.out.println("2：bIsNum="+bIsNum);      //演示是否是英文字符      boolean bIsStr = mA.isString("wer");      System.out.println("1：bIsStr="+bIsStr);      bIsStr = mA.isString("wer3");      System.out.println("2：bIsStr="+bIsStr);      //演示检查日期      int iIsTime = mA.chickData("2003-12-98");      System.out.println("1：iIsTime="+iIsTime);      iIsTime = mA.chickData("2003-111-08");      System.out.println("2：iIsTime="+iIsTime);      iIsTime = mA.chickData("2003-10-08");      System.out.println("3：iIsTime="+iIsTime);      iIsTime = mA.chickData("2000-02-30");      System.out.println("4：iIsTime="+iIsTime);    }  }

[JAVA100例]004、矢量(Vector)对象的操作

public class operateVector { /* *<br>方法说明：生成一个4*4的二维Vector，供使用。 *<br>输入参数： *<br>输出变量：Vector *<br>其它说明： */  public Vector buildVector(){     Vector vTemps = new Vector();     for(int i=0;i<4;i++){     Vector vTemp = new Vector();     for (int j=0;j<4;j++){          vTemp.addElement("Vector("+i+")("+j+")");     }     vTemps.addElement(vTemp);     }     return vTemps;  } /* *<br>方法说明：插入数据 *<br>输入参数：Vector vTemp 待插入的数据对象 *<br>输入参数：int iTemp 插入数据的位置 *<br>输入参数：Object oTemp 插入数据值 *<br>输出变量：Vector 结果 *<br>其它说明：如果插入位置超出实例实际的位置将返回null */  public Vector insert(Vector vTemp,int iTemp,Object oTemp){      if(iTemp>vTemp.size()){    print("数据超界!");    return null;   }else{     vTemp.insertElementAt(oTemp,iTemp);   }   return vTemp;  } /* *<br>方法说明：移除数据 *<br>输入参数：Vector vTemp 待删除矢量对象 *<br>输入参数：int iTemp 删除数据的位置 *<br>输出变量：Vector *<br>其它说明：如果删除超界的数据，将返回null */  public Vector delete(Vector vTemp,int iTemp){      if(iTemp>vTemp.size()){    print("数据超界!");    return null;   }else{     vTemp.removeElementAt(iTemp);   }   return vTemp;  } /* *<br>方法说明：修改数据 *<br>输入参数：Vector vTemp 待修改矢量对象 *<br>输入参数：int iTemp 修改数据的位置 *<br>输入参数：Object oTemp 修改数据值 *<br>输出变量：Vector *<br>其它说明：如果修改位置超界的数据，将返回null */  public Vector updata(Vector vTemp,int iTemp,Object oTemp){      if(iTemp>vTemp.size()){    print("数据超界!");    return null;   }else{     vTemp.setElementAt(oTemp,iTemp);   }   return vTemp;  } /* *<br>方法说明：输出信息 *<br>输入参数：String sTemp 输出信息名称 *<br>输入参数：Object oTemp 输出信息值 *<br>返回变量：无 */  public void print(String sTemp,Vector oTemp){      System.out.println(sTemp+"数据：");      this.print(oTemp);  } /**  *<br>方法说明：打印输出（过载）  *<br>输入参数：Object oPara 输出的对象  *<br>返回类型：无  */  public void print(Object oPara){      System.out.println(oPara);  } /**  *<br>方法说明：打印输出（过载）  *<br>输入参数：Vector vPara 显示输出矢量对象  *<br>返回类型：无  */  public void print(Vector vPara){     for(int i=0;i<vPara.size();i++){      System.out.println(vPara.elementAt(i));     }  } /**  *<br>方法说明：主方法，程序入口  *<br>输入参数：String[] args  *<br>返回类型：无  */  public static void main(String[] args)  {   operateVector ov = new operateVector();   Vector vTemp = ov.buildVector();   ov.print("vTemp0",vTemp);   Vector vResult = ov.insert(vTemp,2,"添加的数据");   ov.print("vResult",vResult);         Vector vResultup = ov.updata(vResult,2,"修改的数据");   ov.print("vResultmp",vResultup);         Vector vResultnow = ov.delete(vResultup,2);   ov.print("vResultnow",vResultnow);  } }

[JAVA100例]005、哈希表(Hashtable)和枚举器

public class RoleRight  {  private static Hashtable rightList = new Hashtable(); /**  *<br>方法说明：初始化数据  *<br>输入参数：  *<br>返回类型：  */  public void init()  {     String[] accRoleList = {"admin","satrap","manager","user","guest"};     String[] rightCodeList = {"10001","10011","10021","20011","24011"};     for(int i=0;i<accRoleList.length;i++)     {       rightList.put(accRoleList[i],rightCodeList[i]);     }  } /**  *<br>方法说明：获取角色权限代码  *<br>输入参数：String accRole 角色名称  *<br>返回类型：String 权限代码  */  public String getRight(String accRole)  {     if(rightList.containsKey(accRole))       return (String)rightList.get(accRole);     else       return null;  } /**  *<br>方法说明：添加角色和代码信息  *<br>输入参数：String accRole 角色名称  *<br>输入参数：String rightCode 角色权限代码  *<br>返回类型：void （无）  */  public void insert(String accRole,String rightCode)  {    rightList.put(accRole,rightCode);  } /**  *<br>方法说明：删除角色权限  *<br>输入参数：String accRole 角色名称  *<br>返回类型：void（无）  */  public void delete(String accRole)  {    if(rightList.containsKey(accRole))      rightList.remove(accRole);  } /**  *<br>方法说明：修改角色权限代码  *<br>输入参数：String accRole 角色名称  *<br>输入参数：String rightCode 角色权限代码  *<br>返回类型：void（无）  */  public void update(String accRole,String rightCode)  {    //this.delete(accRole);    this.insert(accRole,rightCode);  } /**  *<br>方法说明：打印哈希表中角色和代码对应表  *<br>输入参数：无  *<br>返回类型：无  */  public void print()  {   Enumeration RLKey = rightList.keys();   while(RLKey.hasMoreElements())   {    String accRole = RLKey.nextElement().toString();    print(accRole+"="+this.getRight(accRole));   }  } /**  *<br>方法说明：打印信息（过载）  *<br>输入参数：Object oPara 打印的信息内容  *<br>返回类型：无  */  public void print(Object oPara)  {   System.out.println(oPara);  } /**  *<br>方法说明：主方法，  *<br>输入参数：  *<br>返回类型：  */  public static void main(String[] args)  {   RoleRight RR = new RoleRight();   RR.init();   RR.print();   RR.print("___________________________");   RR.insert("presider","10110");   RR.print();   RR.print("___________________________");   RR.update("presider","10100");   RR.print();   RR.print("___________________________");   RR.delete("presider");   RR.print();  }  }//end:)~

public class RoleRight
 {
 private static Hashtable rightList = new Hashtable();
/**
 *<br>方法说明：初始化数据
 *<br>输入参数：
 *<br>返回类型：
 */
 public void init()
 {
    String[] accRoleList = {"admin","satrap","manager","user","guest"};
    String[] rightCodeList = {"10001","10011","10021","20011","24011"};
    for(int i=0;i<accRoleList.length;i++)
    {
      rightList.put(accRoleList[i],rightCodeList[i]);
    }
 }
/**
 *<br>方法说明：获取角色权限代码
 *<br>输入参数：String accRole 角色名称
 *<br>返回类型：String 权限代码
 */
 public String getRight(String accRole)
 {
    if(rightList.containsKey(accRole))
      return (String)rightList.get(accRole);
    else
      return null;
 }
/**
 *<br>方法说明：添加角色和代码信息
 *<br>输入参数：String accRole 角色名称
 *<br>输入参数：String rightCode 角色权限代码
 *<br>返回类型：void （无）
 */
 public void insert(String accRole,String rightCode)
 {
   rightList.put(accRole,rightCode);
 }
/**
 *<br>方法说明：删除角色权限
 *<br>输入参数：String accRole 角色名称
 *<br>返回类型：void（无）
 */
 public void delete(String accRole)
 {
   if(rightList.containsKey(accRole))
     rightList.remove(accRole);
 }
/**
 *<br>方法说明：修改角色权限代码
 *<br>输入参数：String accRole 角色名称
 *<br>输入参数：String rightCode 角色权限代码
 *<br>返回类型：void（无）
 */
 public void update(String accRole,String rightCode)
 {
   //this.delete(accRole);
   this.insert(accRole,rightCode);
 }
/**
 *<br>方法说明：打印哈希表中角色和代码对应表
 *<br>输入参数：无
 *<br>返回类型：无
 */
 public void print()
 {
  Enumeration RLKey = rightList.keys();
  while(RLKey.hasMoreElements())
  {
   String accRole = RLKey.nextElement().toString();
   print(accRole+"="+this.getRight(accRole));
  }
 }
/**
 *<br>方法说明：打印信息（过载）
 *<br>输入参数：Object oPara 打印的信息内容
 *<br>返回类型：无
 */
 public void print(Object oPara)
 {
  System.out.println(oPara);
 }
/**
 *<br>方法说明：主方法，
 *<br>输入参数：
 *<br>返回类型：
 */
 public static void main(String[] args)
 {
  RoleRight RR = new RoleRight();
  RR.init();
  RR.print();
  RR.print("___________________________");
  RR.insert("presider","10110");
  RR.print();
  RR.print("___________________________");
  RR.update("presider","10100");
  RR.print();
  RR.print("___________________________");
  RR.delete("presider");
  RR.print();
 }
 }//end:)~

[JAVA100例]006、类的继承（java100例）

class tree { /**  *<br>方法说明：树的树根  *<br>输入参数：  *<br>返回类型：  */   public void root()   {     String sSite = "土壤中";     String sFunction = "吸收养份";     print("位置："+sSite);     print("功能："+sFunction);   } /**  *<br>方法说明：树的树干  *<br>输入参数：  *<br>返回类型：  */   public void bolo()   {     String sSite = "地面";     String sFunction = "传递养份";     print("位置："+sSite);     print("功能："+sFunction);   } /**  *<br>方法说明：树的树枝  *<br>输入参数：  *<br>返回类型：  */   public void branch()   {     String sSite = "树干上";     String sFunction = "传递养份";     print("位置："+sSite);     print("功能："+sFunction);   } /**  *<br>方法说明：树的叶子  *<br>输入参数：  *<br>返回类型：  */   public void leaf()   {     String sSite = "树梢";     String sFunction = "光合作用";     String sColor = "绿色";     print("位置："+sSite);     print("功能："+sFunction);     print("颜色："+sColor);   } /**  *<br>方法说明：显示信息  *<br>输入参数：Object oPara 显示的信息  *<br>返回类型：  */   public void print(Object oPara)   {     System.out.println(oPara);   } /**  *<br>方法说明：主方法  *<br>输入参数：  *<br>返回类型：  */   public static void  main(String[] arges)   {     tree t = new tree();     t.print("描述一棵树：");     t.print("树根：");     t.root();     t.print("树干：");     t.bolo();     t.print("树枝：");     t.branch();     t.print("树叶：");     t.leaf();   } } /**  * <p>Title: 柳树参数</p>  * <p>Description: 描述柳树的参数</p>  * <p>Copyright: Copyright (c) 2003</p>  * <p>Filename: </p>  * @author 杜江  * @version 1.0  */ class osier extends tree {  /**  *<br>方法说明：过载树的树叶  *<br>输入参数：  *<br>返回类型：  */   public void leaf()   {     super.leaf();     String sShape = "长形";     super.print("形状："+sShape);   }   /**  *<br>方法说明：扩展树的花  *<br>输入参数：  *<br>返回类型：  */   public void flower()   {     print("哈哈，柳树没有花！！");   } /**  *<br>方法说明：主方法  *<br>输入参数：  *<br>返回类型：  */   public static void  main(String[] args)   {     osier o = new osier();     o.print("柳树树根：");     o.root();     o.print("柳树树干：");     o.bolo();     o.print("柳树树枝：");     o.branch();     o.print("柳树树叶：");     o.leaf();     o.print("柳树花：");     o.flower();   } } [JAVA100例]007、接口和抽象类（java100例） //接口 interface player {  int flag = 1;  void play();//播放  void pause();//暂停  void stop();//停止 }//end :) //抽象类 abstract class playing {  public void display(Object oPara)  {    System.out.println(oPara);   }  abstract void winRun(); }//end :) //继承了playing抽象类和实现类player接口 public class newPlay extends playing implements player {   public void play()   {     display("newPlay.play()");//这里只是演示，去掉了代码。   }   public void pause()   {      display("newPlay.pause()");//这里只是演示，去掉了代码。   }   public void stop()   {     display("newPlay.stop()");//这里只是演示，去掉了代码。   }   void winRun()   {     display("newPlay.winRun()");//这里只是演示，去掉了代码。   }   public static void main(String[] args)   {     newPlay p = new newPlay();     p.play();     p.pause();     p.stop();     p.winRun();   } }//end [JAVA100例]008、类的标识和访问控制（java100例） package e8.com; /**  * <p>Title: 标识符</p>  * <p>Description: 演示标识符对类的访问控制</p>  * <p>Copyright: Copyright (c) 2003</p>  * <p>Filename: </p>  * @version 1.0  */ public class classDemo1 { //公有方法  public void mechod1()  {    System.out.println("这是一个公有的方法！任何类都可以访问。");  } //授保护的方法  protected void mechod2()  {    System.out.println("这是一个受到保护的方法！只有子类可以访问。");  } //私有的方法  private void mechod3()  {    System.out.println("这是一个私有的方法！只有类本身才可以访问。");  }  public static void main(String[] args){    classDemo1 d = new classDemo1();    d.mechod1();    d.mechod2();    d.mechod3();  }  }//end  package e8.com; /**  * <p>Title: 标识符</p>  * <p>Description: 演示标识符对类的访问控制</p>  * <p>Copyright: Copyright (c) 2003</p>  * <p>Filename: </p>  * @version 1.0  */ public class classPlay {   public static void main(String[] args){     classDemo1 d = new classDemo1();     d.mechod1();     d.mechod2();     d.mechod3();   } }  package e8.net; import e8.com.*; /**  * <p>Title: 标识符</p>  * <p>Description: 演示标识符对类的访问控制</p>  * <p>Copyright: Copyright (c) 2003</p>  * <p>Filename: </p>  * @version 1.0  */ public class classPlay {   public static void main(String[] args){     classDemo1 d = new classDemo1();     d.mechod1();     d.mechod2();     d.mechod3();   } } [JAVA100例]009、异常的捕获和实现自己的异常类（java100例） /**  * <p>Title: 捕获异常和实现自己的异常类</p>  * <p>Description: 通过继承Exception类来实现自己的异常类。并使用try－catch来捕获这个异常。</p>  * <p>Copyright: Copyright (c) 2003</p>  * <p>Filename: </p>  * @version 1.0  */ class MyException extends Exception {   public MyException() {}   public MyException(String msg) {     super(msg);   }   public MyException(String msg, int x) {     super(msg);     i = x;   }   public int val() { return i; }   private int i; } public class DemoException { /**  *<br>方法说明：使用MyException类中默认的构造器  *<br>输入参数：  *<br>返回类型：  */   public static void a() throws MyException {     System.out.println(       "Throwing MyException from a()");     throw new MyException();   } /**  *<br>方法说明：使用MyException类中带信息的构造器  *<br>输入参数：  *<br>返回类型：  */   public static void b() throws MyException {     System.out.println(       "Throwing MyException from b()");     throw new MyException("Originated in b()");   } /**  *<br>方法说明：使用了MyException中有编码的构造器  *<br>输入参数：  *<br>返回类型：  */   public static void c() throws MyException {     System.out.println(       "Throwing MyException from c()");     throw new MyException(       "Originated in c()", 47);   }   public static void main(String[] args) {     try {       a();     } catch(MyException e) {       e.getMessage();     }     try {       b();     } catch(MyException e) {       e.toString();     }     try {       c();     } catch(MyException e) {       e.printStackTrace();       System.out.println("error code: " + e.val());     }   } } //end :) [JAVA100例]010、创建一个窗体（java100例） import javax.swing.*; import java.awt.*; /**  * <p>Title: 创建自己的窗体</p>  * <p>Description: </p>  * <p>Copyright: Copyright (c) 2003</p>  * <p>Filename: mainFrame.java</p>  * @version 1.0  */ public class mainFrame extends JFrame { /**  *<br>方法说明：构造器，通过传递参数来完成窗体的绘制。  *<br>输入参数：String sTitle 窗体标题  *<br>输入参数：int iWidth 窗体的宽度  *<br>输入参数：int iHeight 窗体的高度  *<br>返回类型：  */   public mainFrame(String sTitle,int iWidth,int iHeight)   {     Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();//获取屏幕尺寸     ImageIcon ii = new ImageIcon("images/middle.gif");     setTitle(sTitle);//设置窗体标题     setIconImage(ii.getImage());//设置窗体的图标     setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);//设置但关闭窗体时退出程序     setSize(iWidth,iHeight);//设置窗体大小     int w = getSize().width;//获取窗体宽度     int h = getSize().height;//获取窗体高度     System.out.println("窗体宽："+w+" 窗体高："+h);     int x = (dim.width-w)/2;     int y = (dim.height-h)/2;     setLocation(x,y);//将窗体移到屏幕中间     setVisible(true);//显示窗体   }   public static void main(String[] args)   {     JFrame.setDefaultLookAndFeelDecorated(true);//使用最新的SWING外观     mainFrame mF = new mainFrame("main Frame Demo",400,300);   } }