初学者如何开发出一个高质量的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）的介绍，以后有时间再写吧。

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);   } }

      简单来说序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化，流的概念这里不用多说(就是I/O)，我们可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间(注：要想将对象传输于网络必须进行流化)！在对对象流进行读写操作时会引发一些问题，而序列化机制正是用来解决这些问题的！

问题的引出：

      如上所述，读写对象会有什么问题呢？比如：我要将对象写入一个磁盘文件而后再将其读出来会有什么问题吗？别急，其中一个最大的问题就是对象引用！举个例子来说：假如我有两个类，分别是A和B，B类中含有一个指向A类对象的引用，现在我们对两个类进行实例化{ A a = new A(); B b = new B(); }，这时在内存中实际上分配了两个空间，一个存储对象a，一个存储对象b，接下来我们想将它们写入到磁盘的一个文件中去，就在写入文件时出现了问题！因为对象b包含对对象a的引用，所以系统会自动的将a的数据复制一份到b中，这样的话当我们从文件中恢复对象时(也就是重新加载到内存中)时，内存分配了三个空间，而对象a同时在内存中存在两份，想一想后果吧，如果我想修改对象a的数据的话，那不是还要搜索它的每一份拷贝来达到对象数据的一致性，这不是我们所希望的！

以下序列化机制的解决方案：

1.保存到磁盘的所有对象都获得一个序列号(1, 2, 3等等)

2.当要保存一个对象时，先检查该对象是否被保存了。

3.如果以前保存过，只需写入"与已经保存的具有序列号x的对象相同"的标记，否则，保存该对象

通过以上的步骤序列化机制解决了对象引用的问题！

序列化的实现：

      将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

例子：

import java.io.*;

public class Test
{
    public static void main(String[] args)
    {
        Employee harry = new Employee("Harry Hacker", 50000);
        Manager manager1 = new Manager("Tony Tester", 80000);
        manager1.setSecretary(harry);
        
        Employee[] staff = new Employee[2];
        
        staff[0] = harry;
        staff[1] = manager1;
        try
        {
            ObjectOutputStream out = new ObjectOutputStream(
                new FileOutputStream("employee.dat")); //输出到文件employee.dat
            out.writeObject(staff);
            out.close();
            
            ObjectInputStream in = new ObjectInputStream(
                new FileInputStream("employee.dat"));
            Employee[] newStaff = (Employee[])in.readObject();//重新构造，恢复对象
            in.close();
  
            /**
             *通过harry对象来加薪
             *将在secretary上反映出来
             */
            newStaff[0].raiseSalary(10);
            
            for (int i = 0; i < newStaff.length; i++)
                System.out.println(newStaff);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    
}

class Employee implements Serializable
{
    public Employee(String n, double s)
    {
        name = n;
        salary = s;
    }
    
    /**
     *加薪水
     */
    public void raiseSalary(double byPercent)
    {
        double raise = salary * byPercent / 100;
        salary += raise;
    }
    
    public String toString()
    {
        return getClass().getName()
            + "[name = "+ name
            + ",salary = "+ salary
            + "]";
    }
    
    private String name;
    private double salary;
}

class Manager extends Employee
{
    public Manager(String n, double s)
    {
        super(n, s);
        secretary = null;
    }
    
    /**
     *设置秘书
     */
    public void setSecretary(Employee s)
    {
        secretary = s;
    }
    
    public String toString()
    {
        return super.toString()
            + "[secretary = "+ secretary
            + "]";
    }
    
    //secretary代表秘书
    private Employee secretary;
}

修改默认的序列化机制：  

      在序列化的过程中，有些数据字段我们不想将其序列化，对于此类字段我们只需要在定义时给它加上transient关键字即可，对于transient字段序列化机制会跳过不会将其写入文件，当然也不可被恢复。但有时我们想将某一字段序列化，但它在SDK中的定义却是不可序列化的类型，这样的话我们也必须把他标注为transient，可是不能写入又怎么恢复呢？好在序列化机制为包含这种特殊问题的类提供了如下的方法定义：

private void readObject(ObjectInputStream in) throws

         IOException, ClassNotFoundException;

private void writeObject(ObjectOutputStream out) throws

         IOException;

(注：这些方法定义时必须是私有的，因为不需要你显示调用，序列化机制会自动调用的)

使用以上方法我们可以手动对那些你又想序列化又不可以被序列化的数据字段进行写出和读入操作。

      下面是一个典型的例子，java.awt.geom包中的Point2D.Double类就是不可序列化的，因为该类没有实现Serializable接口，在我的例子中将把它当作LabeledPoint类中的一个数据字段，并演示如何将其序列化！

import java.io.*;
import java.awt.geom.*;

public class TransientTest
{
    public static void main(String[] args)
    {
        LabeledPoint label = new LabeledPoint("Book", 5.00, 5.00);
        try
        {
            System.out.println(label);//写入前
            ObjectOutputStream out = new ObjectOutputStream(new
                FileOutputStream("Label.txt"));
            out.writeObject(label);
            out.close();
            
            System.out.println(label);//写入后
            
            ObjectInputStream in = new ObjectInputStream(new
                FileInputStream("Label.txt"));
            LabeledPoint label1 = (LabeledPoint)in.readObject();
            in.close();
            System.out.println(label1);//读出并加1.0后
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    
}

class LabeledPoint implements Serializable
{
    public LabeledPoint(String str, double x, double y)
    {
        label = str;
        point = new Point2D.Double(x, y);
    }
    
    private void writeObject(ObjectOutputStream out) throws IOException
    {
        /**
         *必须通过调用defaultWriteObject()方法来写入
         *对象的描述以及那些可以被序列化的字段
         */
        out.defaultWriteObject();
        out.writeDouble(point.getX());
        out.writeDouble(point.getY());
    }
    
    private void readObject(ObjectInputStream in)
        throws IOException, ClassNotFoundException
    {
        /**
         *必须调用defaultReadObject()方法
         */
        in.defaultReadObject();
        double x = in.readDouble() + 1.0;
        double y = in.readDouble() + 1.0;
        point = new Point2D.Double(x, y);
    }
    
    public String toString()
    {
        return getClass().getName()
            + "[label = "+ label
            + ", point.getX() = "+ point.getX()
            + ", point.getY() = "+ point.getY()
            + "]";
    }
    
    private  String label;
    transient private Point2D.Double point;
}

class Node<T> {
         T value;
         Node(T value) {
         this.value = value;
         }
         T getValue() {
           return value;
         }
         void setValue(T value) {
           this.value = value;
         }
      }

垃圾收集趣史

写作本文的初衷是想和大家分享垃圾收集（ Garbage Collection ）技术简单而有趣的发展史。动笔之前，我站在窗边，望了望正在小区里装运垃圾的清洁车。和生活中环卫工人们清运垃圾的工作相似，软件开发里的垃圾收集其实就是一种自动打扫和清除内存垃圾的技术，它可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽（这和生活垃圾堵塞排污管道的危险并没有什么本质的不同），以及不恰当的内存释放所造成的内存非法引用（这类似于我们在生活中买到了一瓶已经过期三年的牛奶）。

据历史学家们介绍，四千多年前的古埃及人已经在城市里建设了完善的排污和垃圾清运设施，一千多年前的中国人更是修筑了当时世界上保洁能力最强的都市——长安。今天，当我们在软件开发中体验自动垃圾收集的便捷与舒适时，我们至少应当知道，这种拒绝杂乱、追求整洁的“垃圾收集”精神其实是人类自古以来就已经具备了的。

	拓荒时代

国内的程序员大多是在 Java 语言中第一次感受到垃圾收集技术的巨大魅力的，许多人也因此把 Java 和垃圾收集看成了密不可分的整体。但事实上，垃圾收集技术早在 Java 语言问世前 30 多年就已经发展和成熟起来了， Java 语言所做的不过是把这项神奇的技术带到了广大程序员身边而已。

如果一定要为垃圾收集技术找一个孪生兄弟，那么， Lisp 语言才是当之无愧的人选。 1960 年前后诞生于 MIT 的 Lisp 语言是第一种高度依赖于动态内存分配技术的语言： Lisp 中几乎所有数据都以“表”的形式出现，而“表”所占用的空间则是在堆中动态分配得到的。 Lisp 语言先天就具有的动态内存管理特性要求 Lisp 语言的设计者必须解决堆中每一个内存块的自动释放问题（否则， Lisp 程序员就必然被程序中不计其数的 free 或 delete 语句淹没），这直接导致了垃圾收集技术的诞生和发展——说句题外话，上大学时，一位老师曾告诉我们， Lisp 是对现代软件开发技术贡献最大的语言。我当时对这一说法不以为然：布满了圆括号，看上去像迷宫一样的 Lisp 语言怎么能比 C 语言或 Pascal 语言更伟大呢？不过现在，当我知道垃圾收集技术、数据结构技术、人工智能技术、并行处理技术、虚拟机技术、元数据技术以及程序员们耳熟能详的许多技术都起源于 Lisp 语言时，我特别想向那位老师当面道歉，并收回我当时的幼稚想法。

知道了 Lisp 语言与垃圾收集的密切关系，我们就不难理解，为什么垃圾收集技术的两位先驱者 J. McCarthy 和 M. L. Minsky 同时也是 Lisp 语言发展史上的重要人物了。 J. McCarthy 是 Lisp 之父，他在发明 Lisp 语言的同时也第一次完整地描述了垃圾收集的算法和实现方式； M. L. Minsky 则在发展 Lisp 语言的过程中成为了今天好几种主流垃圾收集算法的奠基人——和当时不少技术大师的经历相似， J. McCarthy 和 M. L. Minsky 在许多不同的技术领域里都取得了令人艳羡的成就。也许，在 1960 年代那个软件开发史上的拓荒时代里，思维敏捷、意志坚定的研究者更容易成为无所不能的西部硬汉吧。

在了解垃圾收集算法的起源之前，有必要先回顾一下内存分配的主要方式。我们知道，大多数主流的语言或运行环境都支持三种最基本的内存分配方式，它们分别是：

一、静态分配（ Static Allocation ）：静态变量和全局变量的分配形式。我们可以把静态分配的内存看成是家里的耐用家具。通常，它们无需释放和回收，因为没人会天天把大衣柜当作垃圾扔到窗外。

二、自动分配（ Automatic Allocation ）：在栈中为局部变量分配内存的方法。栈中的内存可以随着代码块退出时的出栈操作被自动释放。这类似于到家中串门的访客，天色一晚就要各回各家，除了个别不识时务者以外，我们一般没必要把客人捆在垃圾袋里扫地出门。

三、动态分配（ Dynamic Allocation ）：在堆中动态分配内存空间以存储数据的方式。堆中的内存块好像我们日常使用的餐巾纸，用过了就得扔到垃圾箱里，否则屋内就会满地狼藉。像我这样的懒人做梦都想有一台家用机器人跟在身边打扫卫生。在软件开发中，如果你懒得释放内存，那么你也需要一台类似的机器人——这其实就是一个由特定算法实现的垃圾收集器。

也就是说，下面提到的所有垃圾收集算法都是在程序运行过程中收集并清理废旧“餐巾纸”的算法，它们的操作对象既不是静态变量，也不是局部变量，而是堆中所有已分配内存块。

	引用计数（ Reference Counting ）算法

1960 年以前，人们为胚胎中的 Lisp 语言设计垃圾收集机制时，第一个想到的算法是引用计数算法。拿餐巾纸的例子来说，这种算法的原理大致可以描述为：

午餐时，为了把脑子里突然跳出来的设计灵感记下来，我从餐巾纸袋中抽出一张餐巾纸，打算在上面画出系统架构的蓝图。按照“餐巾纸使用规约之引用计数版”的要求，画图之前，我必须先在餐巾纸的一角写上计数值 1 ，以表示我在使用这张餐巾纸。这时，如果你也想看看我画的蓝图，那你就要把餐巾纸上的计数值加 1 ，将它改为 2 ，这表明目前有 2 个人在同时使用这张餐巾纸（当然，我是不会允许你用这张餐巾纸来擦鼻涕的）。你看完后，必须把计数值减 1 ，表明你对该餐巾纸的使用已经结束。同样，当我将餐巾纸上的内容全部誊写到笔记本上之后，我也会自觉地把餐巾纸上的计数值减 1 。此时，不出意外的话，这张餐巾纸上的计数值应当是 0 ，它会被垃圾收集器——假设那是一个专门负责打扫卫生的机器人——捡起来扔到垃圾箱里，因为垃圾收集器的惟一使命就是找到所有计数值为 0 的餐巾纸并清理它们。

引用计数算法的优点和缺陷同样明显。这一算法在执行垃圾收集任务时速度较快，但算法对程序中每一次内存分配和指针操作提出了额外的要求（增加或减少内存块的引用计数）。更重要的是，引用计数算法无法正确释放循环引用的内存块，对此， D. Hillis 有一段风趣而精辟的论述：

一天，一个学生走到 Moon 面前说：“我知道如何设计一个更好的垃圾收集器了。我们必须记录指向每个结点的指针数目。” Moon 耐心地给这位学生讲了下面这个故事：“一天，一个学生走到 Moon 面前说：‘我知道如何设计一个更好的垃圾收集器了……’”

D. Hillis 的故事和我们小时候常说的“从前有座山，山上有个庙，庙里有个老和尚”的故事有异曲同工之妙。这说明，单是使用引用计数算法还不足以解决垃圾收集中的所有问题。正因为如此，引用计数算法也常常被研究者们排除在狭义的垃圾收集算法之外。当然，作为一种最简单、最直观的解决方案，引用计数算法本身具有其不可替代的优越性。 1980 年代前后， D. P. Friedman ， D. S. Wise ， H. G. Baker 等人对引用计数算法进行了数次改进，这些改进使得引用计数算法及其变种（如延迟计数算法等）在简单的环境下，或是在一些综合了多种算法的现代垃圾收集系统中仍然可以一展身手。

	标记－清除（ Mark-Sweep ）算法

第一种实用和完善的垃圾收集算法是 J. McCarthy 等人在 1960 年提出并成功地应用于 Lisp 语言的标记－清除算法。仍以餐巾纸为例，标记－清除算法的执行过程是这样的：

午餐过程中，餐厅里的所有人都根据自己的需要取用餐巾纸。当垃圾收集机器人想收集废旧餐巾纸的时候，它会让所有用餐的人先停下来，然后，依次询问餐厅里的每一个人：“你正在用餐巾纸吗？你用的是哪一张餐巾纸？”机器人根据每个人的回答将人们正在使用的餐巾纸画上记号。询问过程结束后，机器人在餐厅里寻找所有散落在餐桌上且没有记号的餐巾纸（这些显然都是用过的废旧餐巾纸），把它们统统扔到垃圾箱里。

正如其名称所暗示的那样，标记－清除算法的执行过程分为“标记”和“清除”两大阶段。这种分步执行的思路奠定了现代垃圾收集算法的思想基础。与引用计数算法不同的是，标记－清除算法不需要运行环境监测每一次内存分配和指针操作，而只要在“标记”阶段中跟踪每一个指针变量的指向——用类似思路实现的垃圾收集器也常被后人统称为跟踪收集器（ Tracing Collector ）

伴随着 Lisp 语言的成功，标记－清除算法也在大多数早期的 Lisp 运行环境中大放异彩。尽管最初版本的标记－清除算法在今天看来还存在效率不高（标记和清除是两个相当耗时的过程）等诸多缺陷，但在后面的讨论中，我们可以看到，几乎所有现代垃圾收集算法都是标记－清除思想的延续，仅此一点， J. McCarthy 等人在垃圾收集技术方面的贡献就丝毫不亚于他们在 Lisp 语言上的成就了。

	复制（ Copying ）算法

为了解决标记－清除算法在垃圾收集效率方面的缺陷， M. L. Minsky 于 1963 年发表了著名的论文“一种使用双存储区的 Lisp 语言垃圾收集器（ A LISP Garbage Collector Algorithm Using Serial Secondary Storage ）”。 M. L. Minsky 在该论文中描述的算法被人们称为复制算法，它也被 M. L. Minsky 本人成功地引入到了 Lisp 语言的一个实现版本中。

复制算法别出心裁地将堆空间一分为二，并使用简单的复制操作来完成垃圾收集工作，这个思路相当有趣。借用餐巾纸的比喻，我们可以这样理解 M. L. Minsky 的复制算法：

餐厅被垃圾收集机器人分成南区和北区两个大小完全相同的部分。午餐时，所有人都先在南区用餐（因为空间有限，用餐人数自然也将减少一半），用餐时可以随意使用餐巾纸。当垃圾收集机器人认为有必要回收废旧餐巾纸时，它会要求所有用餐者以最快的速度从南区转移到北区，同时随身携带自己正在使用的餐巾纸。等所有人都转移到北区之后，垃圾收集机器人只要简单地把南区中所有散落的餐巾纸扔进垃圾箱就算完成任务了。下一次垃圾收集的工作过程也大致类似，惟一的不同只是人们的转移方向变成了从北区到南区。如此循环往复，每次垃圾收集都只需简单地转移（也就是复制）一次，垃圾收集速度无与伦比——当然，对于用餐者往返奔波于南北两区之间的辛劳，垃圾收集机器人是决不会流露出丝毫怜悯的。

M. L. Minsky 的发明绝对算得上一种奇思妙想。分区、复制的思路不仅大幅提高了垃圾收集的效率，而且也将原本繁纷复杂的内存分配算法变得前所未有地简明和扼要（既然每次内存回收都是对整个半区的回收，内存分配时也就不用考虑内存碎片等复杂情况，只要移动堆顶指针，按顺序分配内存就可以了），这简直是个奇迹！不过，任何奇迹的出现都有一定的代价，在垃圾收集技术中，复制算法提高效率的代价是人为地将可用内存缩小了一半。实话实说，这个代价未免也太高了一些。

无论优缺点如何，复制算法在实践中都获得了可以与标记－清除算法相比拟的成功。除了 M. L. Minsky 本人在 Lisp 语言中的工作以外，从 1960 年代末到 1970 年代初， R. R. Fenichel 和 J. C. Yochelson 等人也相继在 Lisp 语言的不同实现中对复制算法进行了改进， S. Arnborg 更是成功地将复制算法应用到了 Simula 语言中。

至此，垃圾收集技术的三大传统算法——引用计数算法、标记－清除算法和复制算法——都已在 1960 年前后相继问世，三种算法各有所长，也都存在致命的缺陷。从 1960 年代后期开始，研究者的主要精力逐渐转向对这三种传统算法进行改进或整合，以扬长避短，适应程序设计语言和运行环境对垃圾收集的效率和实时性所提出的更高要求。

	走向成熟

从 1970 年代开始，随着科学研究和应用实践的不断深入，人们逐渐意识到，一个理想的垃圾收集器不应在运行时导致应用程序的暂停，不应额外占用大量的内存空间和 CPU 资源，而三种传统的垃圾收集算法都无法满足这些要求。人们必须提出更新的算法或思路，以解决实践中碰到的诸多难题。当时，研究者的努力目标包括：

第一，提高垃圾收集的效率。使用标记－清除算法的垃圾收集器在工作时要消耗相当多的 CPU 资源。早期的 Lisp 运行环境收集内存垃圾的时间竟占到了系统总运行时间的 40% ！——垃圾收集效率的低下直接造就了 Lisp 语言在执行速度方面的坏名声；直到今天，许多人还条件反射似地误以为所有 Lisp 程序都奇慢无比。

第二，减少垃圾收集时的内存占用。这一问题主要出现在复制算法中。尽管复制算法在效率上获得了质的突破，但牺牲一半内存空间的代价仍然是巨大的。在计算机发展的早期，在内存价格以 KB 计算的日子里，浪费客户的一半内存空间简直就是在变相敲诈或拦路打劫。

第三，寻找实时的垃圾收集算法。无论执行效率如何，三种传统的垃圾收集算法在执行垃圾收集任务时都必须打断程序的当前工作。这种因垃圾收集而造成的延时是许多程序，特别是执行关键任务的程序没有办法容忍的。如何对传统算法进行改进，以便实现一种在后台悄悄执行，不影响——或至少看上去不影响——当前进程的实时垃圾收集器，这显然是一件更具挑战性的工作。

研究者们探寻未知领域的决心和研究工作的进展速度同样令人惊奇：在 1970 年代到 1980 年代的短短十几年中，一大批在实用系统中表现优异的新算法和新思路脱颖而出。正是因为有了这些日趋成熟的垃圾收集算法，今天的我们才能在 Java 或 .NET 提供的运行环境中随心所欲地分配内存块，而不必担心空间释放时的风险。

	标记－整理（ Mark-Compact ）算法

标记－整理算法是标记－清除算法和复制算法的有机结合。把标记－清除算法在内存占用上的优点和复制算法在执行效率上的特长综合起来，这是所有人都希望看到的结果。不过，两种垃圾收集算法的整合并不像 1 加 1 等于 2 那样简单，我们必须引入一些全新的思路。 1970 年前后， G. L. Steele ， C. J. Cheney 和 D. S. Wise 等研究者陆续找到了正确的方向，标记－整理算法的轮廓也逐渐清晰了起来：

在我们熟悉的餐厅里，这一次，垃圾收集机器人不再把餐厅分成两个南北区域了。需要执行垃圾收集任务时，机器人先执行标记－清除算法的第一个步骤，为所有使用中的餐巾纸画好标记，然后，机器人命令所有就餐者带上有标记的餐巾纸向餐厅的南面集中，同时把没有标记的废旧餐巾纸扔向餐厅北面。这样一来，机器人只消站在餐厅北面，怀抱垃圾箱，迎接扑面而来的废旧餐巾纸就行了。

实验表明，标记－整理算法的总体执行效率高于标记－清除算法，又不像复制算法那样需要牺牲一半的存储空间，这显然是一种非常理想的结果。在许多现代的垃圾收集器中，人们都使用了标记－整理算法或其改进版本。

	增量收集（ Incremental Collecting ）算法

对实时垃圾收集算法的研究直接导致了增量收集算法的诞生。

最初，人们关于实时垃圾收集的想法是这样的：为了进行实时的垃圾收集，可以设计一个多进程的运行环境，比如用一个进程执行垃圾收集工作，另一个进程执行程序代码。这样一来，垃圾收集工作看上去就仿佛是在后台悄悄完成的，不会打断程序代码的运行。

在收集餐巾纸的例子中，这一思路可以被理解为：垃圾收集机器人在人们用餐的同时寻找废弃的餐巾纸并将它们扔到垃圾箱里。这个看似简单的思路会在设计和实现时碰上进程间冲突的难题。比如说，如果垃圾收集进程包括标记和清除两个工作阶段，那么，垃圾收集器在第一阶段中辛辛苦苦标记出的结果很可能被另一个进程中的内存操作代码修改得面目全非，以至于第二阶段的工作没有办法开展。

M. L. Minsky 和 D. E. Knuth 对实时垃圾收集过程中的技术难点进行了早期的研究， G. L. Steele 于 1975 年发表了题为“多进程整理的垃圾收集（ Multiprocessing compactifying garbage collection ）”的论文，描述了一种被后人称为“ Minsky-Knuth-Steele 算法”的实时垃圾收集算法。 E. W. Dijkstra ， L. Lamport ， R. R. Fenichel 和 J. C. Yochelson 等人也相继在此领域做出了各自的贡献。 1978 年， H. G. Baker 发表了“串行计算机上的实时表处理技术（ List Processing in Real Time on a Serial Computer ）”一文，系统阐述了多进程环境下用于垃圾收集的增量收集算法。

增量收集算法的基础仍是传统的标记－清除和复制算法。增量收集算法通过对进程间冲突的妥善处理，允许垃圾收集进程以分阶段的方式完成标记、清理或复制工作。详细分析各种增量收集算法的内部机理是一件相当繁琐的事情，在这里，读者们需要了解的仅仅是： H. G. Baker 等人的努力已经将实时垃圾收集的梦想变成了现实，我们再也不用为垃圾收集打断程序的运行而烦恼了。

	分代收集（ Generational Collecting ）算法

和大多数软件开发技术一样，统计学原理总能在技术发展的过程中起到强力催化剂的作用。 1980 年前后，善于在研究中使用统计分析知识的技术人员发现，大多数内存块的生存周期都比较短，垃圾收集器应当把更多的精力放在检查和清理新分配的内存块上。这个发现对于垃圾收集技术的价值可以用餐巾纸的例子概括如下：

如果垃圾收集机器人足够聪明，事先摸清了餐厅里每个人在用餐时使用餐巾纸的习惯——比如有些人喜欢在用餐前后各用掉一张餐巾纸，有的人喜欢自始至终攥着一张餐巾纸不放，有的人则每打一个喷嚏就用去一张餐巾纸——机器人就可以制定出更完善的餐巾纸回收计划，并总是在人们刚扔掉餐巾纸没多久就把垃圾捡走。这种基于统计学原理的做法当然可以让餐厅的整洁度成倍提高。

D. E. Knuth ， T. Knight ， G. Sussman 和 R. Stallman 等人对内存垃圾的分类处理做了最早的研究。 1983 年， H. Lieberman 和 C. Hewitt 发表了题为“基于对象寿命的一种实时垃圾收集器（ A real-time garbage collector based on the lifetimes of objects ）”的论文。这篇著名的论文标志着分代收集算法的正式诞生。此后，在 H. G. Baker ， R. L. Hudson ， J. E. B. Moss 等人的共同努力下，分代收集算法逐渐成为了垃圾收集领域里的主流技术。

分代收集算法通常将堆中的内存块按寿命分为两类，年老的和年轻的。垃圾收集器使用不同的收集算法或收集策略，分别处理这两类内存块，并特别地把主要工作时间花在处理年轻的内存块上。分代收集算法使垃圾收集器在有限的资源条件下，可以更为有效地工作——这种效率上的提高在今天的 Java 虚拟机中得到了最好的证明。

	应用浪潮

	大势所趋

    一种是继承自Thread类.Thread 类是一个具体的类，即不是抽象类，该类封装了线程的行为。要创建一个线程，程序员必须创建一个从 Thread 类导出的新类。程序员通过覆盖 Thread 的 run() 函数来完成有用的工作。用户并不直接调用此函数；而是通过调用 Thread 的 start() 函数，该函数再调用 run()。
   
    例如:

    public class Test extends Thread{
      public Test(){
      }
      public static void main(String args[]){
        Test t1 = new Test();
        Test t2 = new Test();
        t1.start();
        t2.start();
      }
      public void run(){
        //do thread's things
      }
    }

----------------------------
   
    另一种是实现Runnable接口,此接口只有一个函数，run()，此函数必须由实现了此接口的类实现。
   
    例如: public class Test implements Runnable{
      Thread thread1;
      Thread thread2;
      public Test(){
        thread1 = new Thread(this,"1");
        thread2 = new Thread(this,"2");
      }
      public static void main(String args[]){
        Test t = new Test();
        t.startThreads();
      }
      public void run(){
        //do thread's things
      }
      public void startThreads(){
        thread1.start();
        thread2.start();
      }
    }

    两种创建方式差别不大,第一种因为继承自Thread,只创建了自身对象,第二种还得创建Thread对象.但是当你想继承某一其它类时,你只能用后一种方式.大多数人偏爱后一种的原因大概也在于此吧.

-------------------------

    下面我们来讲synchronized的4种用法吧:

    1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.这时,线程获得的是成员锁,即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入.
 
      例如:

      public synchronized void synMethod() {
        //方法体
      }

    2.对某一代码块使用,synchronized后跟括号,括号里是变量,这样,一次只有一个线程进入该代码块.此时,线程获得的是成员锁.例如:

public int synMethod(int a1){
        synchronized(a1) {
          //一次只能有一个线程进入
        }
      }
    3.synchronized后面括号里是一对象,此时,线程获得的是对象锁.例如:

  public class MyThread implements Runnable {
    public static void main(String args[]) {
    MyThread mt = new MyThread();
    Thread t1 = new Thread(mt, "t1");
    Thread t2 = new Thread(mt, "t2");
    Thread t3 = new Thread(mt, "t3");
    Thread t4 = new Thread(mt, "t4");
    Thread t5 = new Thread(mt, "t5");
    Thread t6 = new Thread(mt, "t6");
    t1.start();
    t2.start();
    t3.start();
    t4.start();
    t5.start();
    t6.start();
  }

  public void run() {
    synchronized (this) {
      System.out.println(Thread.currentThread().getName());
    }
  }
}
 
    对于3,如果线程进入,则得到当前对象锁,那么别的线程在该类所有对象上的任何操作都不能进行.在对象级使用锁通常是一种比较粗糙的方法。为什么要将整个对象都上锁，而不允许其他线程短暂地使用对象中其他同步方法来访问共享资源？如果一个对象拥有多个资源，就不需要只为了让一个线程使用其中一部分资源，就将所有线程都锁在外面。由于每个对象都有锁，可以如下所示使用虚拟对象来上锁：class FineGrainLock {

   MyMemberClass x, y;
   Object xlock = new Object(), ylock = new Object();

   public void foo() {
      synchronized(xlock) {
         //access x here
      }

      //do something here - but don't use shared resources

      synchronized(ylock) {
         //access y here
      }
   }

   public void bar() {
      synchronized(this) {
         //access both x and y here
      }
      //do something here - but don't use shared resources
   }
  }

    4.synchronized后面括号里是类,此时,线程获得的是对象锁.例如:

  class ArrayWithLockOrder{
  private static long num_locks = 0;
  private long lock_order;
  private int[] arr;

  public ArrayWithLockOrder(int[] a)
  {
    arr = a;
    synchronized(ArrayWithLockOrder.class) {//-----这里
      num_locks++;             // 锁数加 1。
      lock_order = num_locks;  // 为此对象实例设置唯一的 lock_order。
    }
  }
  public long lockOrder()
  {
    return lock_order;
  }
  public int[] array()
  {
    return arr;
  }
  }

  class SomeClass implements Runnable
 {
  public int sumArrays(ArrayWithLockOrder a1,
                       ArrayWithLockOrder a2)
  {
    int value = 0;
    ArrayWithLockOrder first = a1;       // 保留数组引用的一个
    ArrayWithLockOrder last = a2;        // 本地副本。
    int size = a1.array().length;
    if (size == a2.array().length)
    {
      if (a1.lockOrder() > a2.lockOrder())  // 确定并设置对象的锁定
      {                                     // 顺序。
        first = a2;
        last = a1;
      }
      synchronized(first) {              // 按正确的顺序锁定对象。
        synchronized(last) {
          int[] arr1 = a1.array();
          int[] arr2 = a2.array();
          for (int i=0; i<size; i++)
            value += arr1[i] + arr2[i];
        }
      }
    }
    return value;
}
  public void run() {
    //...
  }
  }
    对于4,如果线程进入,则线程在该类中所有操作不能进行,包括静态变量和静态方法,实际上,对于含有静态方法和静态变量的代码块的同步,我们通常用4来加锁.

  -----------------------------

  下面谈一谈一些常用的方法:

  wait(),wait(long),notify(),notifyAll()等方法是当前类的实例方法,
   
        wait()是使持有对象锁的线程释放锁;
        wait(long)是使持有对象锁的线程释放锁时间为long(毫秒)后,再次获得锁,wait()和wait(0)等价;
        notify()是唤醒一个正在等待该对象锁的线程,如果等待的线程不止一个,那么被唤醒的线程由jvm确定;
        notifyAll是唤醒所有正在等待该对象锁的线程.
        在这里我也重申一下,我们应该优先使用notifyAll()方法,因为唤醒所有线程比唤醒一个线程更容易让jvm找到最适合被唤醒的线程.

    对于上述方法,只有在当前线程中才能使用,否则报运行时错误java.lang.IllegalMonitorStateException: current thread not owner.

  --------------------------

    下面,我谈一下synchronized和wait()、notify()等的关系:

    其实用生产者/消费者这个例子最好说明他们之间的关系了:

    public class test {
  public static void main(String args[]) {
    Semaphore s = new Semaphore(1);
    Thread t1 = new Thread(s, "producer1");
    Thread t2 = new Thread(s, "producer2");
    Thread t3 = new Thread(s, "producer3");
    Thread t4 = new Thread(s, "consumer1");
    Thread t5 = new Thread(s, "consumer2");
 Thread t6 = new Thread(s, "consumer3");
    t1.start();
    t2.start();
    t3.start();
    t4.start();
    t5.start();
    t6.start();
  }
  }

  class Semaphore
     implements Runnable {
  private int count;
  public Semaphore(int n) {
    this.count = n;
  }

  public synchronized void acquire() {
    while (count == 0) {
      try {
        wait();
      }
      catch (InterruptedException e) {
        //keep trying
      }
    }
    count--;
  }

  public synchronized void release() {
    while (count == 10) {
      try {
        wait();
      }
  catch (InterruptedException e) {
        //keep trying
      }
    }
    count++;
    notifyAll(); //alert a thread that's blocking on this semaphore
  }

  public void run() {
    while (true) {
      if (Thread.currentThread().getName().substring(0,8).equalsIgnoreCase("consumer")) {
        acquire();
      }
      else if (Thread.currentThread().getName().substring(0,8).equalsIgnoreCase("producer")) {
        release();
      }
      System.out.println(Thread.currentThread().getName() + " " + count);
    }
    }
  }
       生产者生产,消费者消费,一般没有冲突,但当库存为0时,消费者要消费是不行的,但当库存为上限(这里是10)时,生产者也不能生产.请好好研读上面的程序,你一定会比以前进步很多.

      上面的代码说明了synchronized和wait,notify没有绝对的关系,在synchronized声明的方法、代码块中,你完全可以不用wait,notify等方法,但是,如果当线程对某一资源存在某种争用的情况下,你必须适时得将线程放入等待或者唤醒.

文章终于写完了,基本上将我学习所得全部写出来了,不过也留下些许遗憾,比如synchronized后是类时的深入的说明及讨论.而且,文章由于自己能力有限,有些地方肯定会有错误,希望看过有何建议和批评,请发帖在下面,我会修正该文.谢谢!

　　第二，Anonymous Inner Class （匿名内部类） 是否可以extends（继承）其它类，是否可以implements（实现）interface（接口）？

　　第三，Static Nested Class 和 Inner Class的不同，说得越多越好（面试题有的很笼统）。

　　第四，&和&&的区别。

　　第五，HashMap和Hashtable的区别。

　　第六，Collection 和 Collections的区别。

　　第七，什么时候用assert.

　　第八，GC是什么？ 为什么要有GC？

　　第九，String s = new String（"xyz"）；创建了几个String Object？

　　第十，Math.round（11.5）等於多少？ Math.round（-11.5）等於多少？

　　第十一，short s1 = 1； s1 = s1 + 1；有什么错？ short s1 = 1； s1 += 1；有什么错？

　　第十二，sleep（） 和 wait（） 有什么区别？

　　第十三，Java有没有goto？

　　第十四，数组有没有length（）这个方法？ String有没有length（）这个方法？

　　第十五，Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型？

　　第十六，Set里的元素是不能重复的，那么用什么方法来区分重复与否呢？ 是用==还是equals（）？ 它们有何区别？

　　第十七，给我一个你最常见到的runtime exception.

　　第十八，error和exception有什么区别？

　　第十九，List， Set， Map是否继承自Collection接口？

　　第二十，abstract class和interface有什么区别？

　　第二十一，abstract的method是否可同时是static，是否可同时是native，是否可同时是synchronized？

　　第二十二，接口是否可继承接口？ 抽象类是否可实现（implements）接口？ 抽象类是否可继承实体类（concrete class）？

　　第二十三，启动一个线程是用run（）还是start（）？

　　第二十四，构造器Constructor是否可被override？

　　第二十五，是否可以继承String类？

　　第二十六，当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法？

　　第二十七，try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后？

　　第二十八，编程题： 用最有效率的方法算出2乘以8等於几？

　　第二十九，两个对象值相同（x.equals（y） == true），但却可有不同的hash code，这句话对不对？

　　第三十，当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递？

　　第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上？

　　第三十二，编程题： 写一个Singleton出来。

　　以下是答案

　　第一，谈谈final， finally， finalize的区别。

　　final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。

　　finalize—方法名。Java 技术允许使用 finalize（） 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize（） 方法以整理系统资源或者执行其他清理工作。finalize（） 方法是在垃圾收集器删除对象之前对这个对象调用的。

　　第二，Anonymous Inner Class （匿名内部类） 是否可以extends（继承）其它类，是否可以implements（实现）interface（接口）？

　　匿名的内部类是没有名字的内部类。不能extends（继承） 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。

　　第三，Static Nested Class 和 Inner Class的不同，说得越多越好（面试题有的很笼统）。

　　Nested Class （一般是C++的说法），Inner Class （一般是JAVA的说法）。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。具体可见http： //www.frontfree.net/articles/services/view.asp？id=704&page=1注： 静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

　　第四，&和&&的区别。

　　&是位运算符。&&是布尔逻辑运算符。

　　第五，HashMap和Hashtable的区别。

　　都属于Map接口的类，实现了将惟一键映射到特定的值上。

　　HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。

　　Hashtable 类似于 HashMap，但是不允许 null 键和 null 值。它也比 HashMap 慢，因为它是同步的。

　　第六，Collection 和 Collections的区别。

　　Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。

　　Collection是个java.util下的接口，它是各种集合结构的父接口。

　　第七，什么时候用assert.断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true.如果表达式计算为 false，那么系统会报告一个 AssertionError.它用于调试目的：assert（a > 0）； // throws an AssertionError if a <= 0断言可以有两种形式：assert Expression1 ；assert Expression1 ： Expression2 ；Expression1 应该总是产生一个布尔值。

　　Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 String 消息。

　　断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记：javac -source 1.4 Test.java要在运行时启用断言，可使用 -enableassertions 或者 -ea 标记。

　　要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。

　　要系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用断言。

　　可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。

　　第八，GC是什么？ 为什么要有GC？ （基础）。

　　GC是垃圾收集器。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：System.gc（）

　　Runtime.getRuntime（）。gc（）

　　第九，String s = new String（"xyz"）；创建了几个String Object？

　　两个对象，一个是“xyx”，一个是指向“xyx”的引用对象s.

　　第十，Math.round（11.5）等於多少？ Math.round（-11.5）等於多少？

　　Math.round（11.5）返回（long）12，Math.round（-11.5）返回（long）-11；

　　第十一，short s1 = 1； s1 = s1 + 1；有什么错？ short s1 = 1； s1 += 1；有什么错？

　　short s1 = 1； s1 = s1 + 1；有错，s1是short型，s1+1是int型，不能显式转化为short型。可修改为s1 =（short）（s1 + 1） .short s1 = 1； s1 += 1正确。

　　第十二，sleep（） 和 wait（） 有什么区别？ 搞线程的最爱sleep（）方法是使线程停止一段时间的方法。在sleep 时间间隔期满后，线程不一定立即恢复执行。这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行，除非（a）“醒来”的线程具有更高的优先级（b）正在运行的线程因为其它原因而阻塞。

　　wait（）是线程交互时，如果线程对一个同步对象x 发出一个wait（）调用，该线程会暂停执行，被调对象进入等待状态，直到被唤醒或等待时间到。

　　第十三，Java有没有goto？

　　Goto—java中的保留字，现在没有在java中使用。

　　第十四，数组有没有length（）这个方法？ String有没有length（）这个方法？

　　数组没有length（）这个方法，有length的属性。

　　String有有length（）这个方法。

　　第十五，Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型？

　　方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 （Overriding）。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载（Overloading）。Overloaded的方法是可以改变返回值的类型。

　　第十六，Set里的元素是不能重复的，那么用什么方法来区分重复与否呢？ 是用==还是equals（）？ 它们有何区别？

　　Set里的元素是不能重复的，那么用iterator（）方法来区分重复与否。equals（）是判读两个Set是否相等。

　　equals（）和==方法决定引用值是否指向同一对象equals（）在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

　　第十七，给我一个你最常见到的runtime exception. ArithmeticException， ArrayStoreException， BufferOverflowException， BufferUnderflowException， CannotRedoException， CannotUndoException， ClassCastException， CMMException， ConcurrentModificationException， DOMException， EmptyStackException， IllegalArgumentException， IllegalMonitorStateException， IllegalPathStateException， IllegalStateException，ImagingOpException， IndexOutOfBoundsException， MissingResourceException， NegativeArraySizeException， NoSuchElementException， NullPointerException， ProfileDataException， ProviderException， RasterFormatException， SecurityException， SystemException， UndeclaredThrowableException， UnmodifiableSetException， UnsupportedOperationException

　　第十八，error和exception有什么区别？

　　error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。

　　exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

　　第十九，List， Set， Map是否继承自Collection接口？

　　List，Set是

　　Map不是

　　第二十，abstract class和interface有什么区别？

　　声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

　　接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

　　第二十一，abstract的method是否可同时是static，是否可同时是native，是否可同时是synchronized？

　　都不能

　　第二十二，接口是否可继承接口？ 抽象类是否可实现（implements）接口？ 抽象类是否可继承实体类（concrete class）？

　　接口可以继承接口。抽象类可以实现（implements）接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。

　　第二十三，启动一个线程是用run（）还是start（）？

　　启动一个线程是调用start（）方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run（）方法可以产生必须退出的标志来停止一个线程。

　　第二十四，构造器Constructor是否可被override？

　　构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading.

　　第二十五，是否可以继承String类？

　　String类是final类故不可以继承。

　　第二十六，当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法？

　　不能，一个对象的一个synchronized方法只能由一个线程访问。

　　第二十七，try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后？

　　会执行，在return前执行。

　　第二十八，编程题： 用最有效率的方法算出2乘以8等於几？

　　有C背景的程序员特别喜欢问这种问题。

　　2 << 3

　　第二十九，两个对象值相同（x.equals（y） == true），但却可有不同的hash code，这句话对不对？

　　不对，有相同的hash code.

　　第三十，当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递？

　　是值传递。Java 编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

　　第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上？

　　switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte.long，string 都不能作用于swtich.

　　第三十二，编程题： 写一个Singleton出来。

　　Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

　　一般Singleton模式通常有几种种形式：第一种形式： 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用，继而调用其中的方法。

　　public class Singleton { private Singleton（）{} //在自己内部定义自己一个实例，是不是很奇怪？

　　//注意这是private 只供内部调用private static Singleton instance = new Singleton（）；//这里提供了一个供外部访问本class的静态方法，可以直接访问public static Singleton getInstance（） { return instance；}第二种形式：public class Singleton { private static Singleton instance = null；public static synchronized Singleton getInstance（） { //这个方法比上面有所改进，不用每次都进行生成对象，只是第一次//使用时生成实例，提高了效率！

　　if （instance==null）

　　instance＝new Singleton（）；return instance； 　　} }其他形式：定义一个类，它的构造函数为private的，所有方法为static的。

　　一般认为第一种形式要更加安全些第三十三 Hashtable和HashMap Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现

　　HashMap允许将null作为一个entry的key或者value，而Hashtable不允许

　　还有就是，HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey.因为contains方法容易让人引起误解。

　　最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供外同步。

　　Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。
 
 

 离开GEF项目组已经一个多月了，但是那段日子给我很深的印象，因为那仿佛是我真正下定决心，学习成为一个好的IT人员之路的开始。而且开始积累编程经验。GEF并不简单，面对这个拦路虎，我很是兴奋，想把那段时间的学习体会以及我们的项目来个大致的介绍。

   我们的项目是一个Eclipse平台上的用于本体建模的图形编辑器，大家决定采用GEF框架，因为它非常适合开发带有调色板的以编辑器为主要部件的应用程序。刚开始一个星期，非常迷茫，不知从何下手。这里要非常感谢八进制的blog，他写的关于GEF的系列给了我很大的帮助，至今我还有很多没有完全消化的地方。

一.   入门

我们选取了一个GefPractice的例子作为学习的对象。它的结构很清楚，包划分得很容易理解（现在发现包的划分基本是按照gef api中包的划分来的）。它实现了一个简单得编辑器的功能，可以创建节点、编辑节点和删除节点，还可以创建节点之间的连接。它一共划分了10个包：

1．              ui包：这里是用户界面，主要是编辑器editor,编辑器一般是继承GraphicalEditorWithPalette，这样我们就可以得到一个GraphicalViewer和一个PaletteViewer。我认为学习从ui入手比较简单，因为我们一般和editor接触比较多，对于GEF内部工作机制的了解也应从editor开始，这样更直观。Editor中有几个重要的概念：

①     在editor的构造函数中，调用setEditDomain()方法，而使用的一般就是DefaultEditDomain(),它是EditDomain的一个默认实现。它是一个GEF程序的状态集合，包括命令栈，一个或多个EditpartViewer，和当前的活动工具。

②     两个方法：configureGraphicalViewer()和initialGraphicalViewer(). configureCraphicalViewer()方法中替graphicalViewer设置rootEditPart，设置EditPartFactory。InitalGraphicalViewer()方法中，替graphicalViewer设置contentProvider，一般是画布(model包中)，设置拖放监听器(这个以后还要重点说明)。

③     GetAdapt()方法，应该是视图之间的切换(这个现在还不太清楚)。

④     内部类继承ContentOutlinePage实现大纲视图。

2.model包：

模型：GEF的模型只与控制器打交道，而不知道任何与视图有关的东西。为了能让控制器知道模型的变化，应该把控制器作为事件监听者注册在模型中，当模型发生变化时，就触发相应的事件给控制器，后者负责通知各个视图进行更新。

类之间的层次关系

在org.sklse.oed本题编辑器项目中，创建了org.sklse.oed.model包来装载模型，在设计中，我们结合java程序面向对象的特点，将创建的类抽象成三个层次，如下图：

AbstractModel作为整个模块的根类，实现模型层接点和连线公用的监听接口，属性变化监听事件。主要是通过implements IpropertySource来实现的，IpropertySource是eclipse中关于属性视图开发方面的接口。

结点父类：AbstractNodeModel.class

该类抽象出结点公用的一些属性和方法，比如：定义了P_CONSTRAINT、P_TEXT、P_SOURCE_CONNECTION、P_TARGET_CONNECTION等属性，其中P_CONSTRAINT用来布局的，P_TEXT是模型的名字，而P_SOURCE_CONNECTION、P_TARGET_CONNECTION用来存放模型的源连接和目的连接的链表。

然后根据这些属性定义一系列相关的操作，比如：

public void addSourceConnection(Object connx) {

              sourceConnections.add(connx);

              firePropertyChange(P_SOURCE_CONNECTION, null, null);

       }

上面就是一个很典型的方法，目的是给模型对象添加一个源连接，参数connx表示源连接，sourceConnections.add(connx);是源链表的添加方法，firePropertyChange(P_SOURCE_CONNECTION, null, null)方法来激活属性变化事件。正如mvc模式的思想一样，在模型被修改的同时，通过消息事件通知控制层（firePropertyChange），后者根据模型变化来修改视图。

连线父类：AbstractConnectionModel.class

该类抽象出连线公用的一些属性和方法，连线最重要的属性就是P_BEND_POINT ，我把它理解成拐点，即可以通过拖动这个拐点来折变连线。一条连线就必须有源接点和目的接点，即source, target，在model层增加一个连线，也就等于在source和target的源接点连表和目的接点链表上增加这条记录。有这类方法：

public void attachSource() {        

              if (!source.getModelSourceConnections().contains(this))

                     source.addSourceConnection(this);

       }

对于P_BEND_POINT属性的变化也必须有一套方法：

public void addBendpoint(int index, Point point) {

              bendpoints.add(index, point);

              firePropertyChange(P_BEND_POINT, null, null);

       }

画板模型：ContentModel.class

编辑区的画板模型,相当于母版，其他图形都是添加到它上面的。

//定义一个属性

public static final String P_CHILDREN = "_children";

//定义一个存放孩子接点的链表

private List children = new ArrayList();

public void addChild(Object child) {//添加孩子结点

              children.add(child);

              firePropertyChange(P_CHILDREN, null, null);//激活属性变化事件

       }

原文地址：http://www.cnblogs.com/bjzhanghao/archive/2005/02/19/106000.html
构造一个GEF应用程序通常分为这么几个步骤：设计模型、设计EditPart和Figure、设计EditPolicy和Command，其中EditPart是最主要的一部分，因为在实现它的时候不可避免的要使用到EditPolicy，而后者又涉及到Command。

现在我们来看个例子，它的功能非常简单，用户可以在画布上增加节点（Node）和节点间的连接，可以直接编辑节点的名称以及改变节点的位置，用户可以撤消/重做任何操作，有一个树状的大纲视图和一个属性页。点此下载，这是一个Eclipse的项目打包文件，在Eclipse里导入后运行Run-time Workbench，新建一个扩展名为"gefpractice"的文件就会打开这个编辑器。

图1 Practice Editor的使用界面

你可以参考着代码来看接下来的内容了，让我们从模型开始说起。模型是根据应用需求来设计的，所以我们的模型包括代表整个图的Diagram、代表节点的Node和代表连接的Connection这些对象。我们知道，模型是要负责把自己的改变通知给EditPart的，为了把这个功能分离出来，我们使用名为Element的抽象类专门来实现通知机制，然后让其他模型类继承它。Element类里包括一个PropertyChangeSupport类型的成员变量，并提供了addPropertyChangeListener()、removePropertyChangeListener()和fireXXX()方法分别用来注册监听器和通知监听器模型改变事件。在GEF里，模型的监听器就是EditPart，在EditPart的active()方法里我们会把它作为监听器注册到模型中。所以，总共有四个类组成了我们的模型部分。（Element,Node,Diagram,Connection)

在前面的贴子里说过，大部分GEF应用程序都是实现为Editor的，这个例子也不例外，对应的Editor名为PracticeEditor。这个Editor继承了GraphicalEditorWithPalette类，表示它是一个具有调色板的图形编辑器。最重要的两个方法是configureGraphicalViewer()和initializeGraphicalViewer()，分别用来定制和初始化EditPartViewer（关于EditPartViewer的作用请查看前面的帖子），简单查看一下GEF的代码你会发现，在GraphicalEditor类里会先后调用这两个方法，只是中间插了一个hookGraphicalViewer()方法，其作用是同步选择和把EditPartViewer作为SelectionProvider注册到所在的site（Site是Workbench的概念，请查Eclipse帮助）。所以，与选择无关的初始化操作应该在前者中完成，否则放在后者完成。例子中，在这两个方法里我们配置了RootEditPart、用于创建EditPart的EditPartFactory、Contents即Diagram对象和增加了拖放支持，拖动目标是当前EditPartViewer，后面会看到拖动源就是调色板。

这个Editor是带有调色板的，所以要告诉GEF我们的调色板里都有哪些工具，这是通过覆盖getPaletteRoot()方法来实现的。在这个方法里，我们利用自己写的一个工具类PaletteFactory构造一个PaletteRoot对象并返回，我们的调色板里需要有三种工具：选择工具、节点工具和连接工具。在GEF里，调色板里可以有抽屉（PaletteDrawer）把各种工具归类放置，每个工具都是一个ToolEntry，选择工具（SelectionToolEntry）和连接工具（ConnectionCreationToolEntry）是预先定义好的几种工具中的两个，所以可以直接使用。对于节点工具，要使用CombinedTemplateCreationEntry，并把节点类型作为参数之一传给它，创建节点工具的代码如下所示。

ToolEntry tool = new CombinedTemplateCreationEntry("Node", "Create a new Node", Node.class, new SimpleFactory(Node.class), null, null);

在新的3.0版本GEF里还提供了一种可以自动隐藏调色板的编辑器GraphicalEditorWithFlyoutPalette，对调色板的外观有更多选项可以选择，以后的帖子里可能会提到如何使用。

调色板的初始化操作应该放在initializePaletteViewer()里完成，最主要的任务是为调色板所在的EditPartViewer添加拖动源事件支持，前面我们已经为画布所在EditPartViewer添加了拖动目标事件，所以现在就可以实现完整的拖放操作了。这里稍微讲解一下拖放的实现原理，以用来创建节点对象的节点工具为例，它在调色板里是一个CombinedTemplateCreationEntry，在创建这个PaletteEntry时（见上面的代码）我们指定该对象对应一个Node.class，所以在用户从调色板里拖动这个工具时，内存里有一个TemplateTransfer单例对象会记录下Node.class（称作template），当用户在画布上松开鼠标时，拖放结束的事件被触发，将由画布注册的DiagramTemplateTransferDropTargetListener对象来处理template对象（现在是Node.class），在例子中我们的处理方法是用一个名为ElementFactory的对象负责根据这个template创建一个对应类型的实例。

以上我们建立了模型和用于实现视图的Editor，因为模型的改变都是由Command对象直接修改的，所以下面我们先来看都有哪些Command。由需求可知，我们对模型的操作有增加/删除节点、修改节点名称、改变节点位置和增加/删除连接等，所以对应就有CreateNodeCommand、DeleteNodeCommand、RenameNodeCommand、MoveNodeCommand、CreateConnectionCommand和DeleteConnectionCommand这些对象，它们都放归类在commands包里。一个Command对象里最重要的当然是execute()方法了，也就是执行命令的方法。除此以外，因为要实现撤消/重做功能，所以在Command对象里都有Undo()和Redo()方法，同时在Command对象里要有成员变量负责保留执行该命令时的相关状态，例如RenameNodeCommand里要有oldName和newName两个变量，这样才能正确的执行Undo()和Redo()方法，要记住，每个被执行过的Command对象实例都是被保存在EditDomain的CommandStack中的。

例子里的EditPolicy都放在policies包里，与图形有关的（GraphicalEditPart的子类）有DiagramLayoutEditPolicy、NodeDirectEditPolicy和NodeGraphicalNodeEditPolicy，另外两个则是与图形无关的编辑策略。可以看到，在后一种类型的两个类（ConnectionEditPolicy和NodeEditPolicy）中我们只覆盖了createDeleteCommand()方法，该方法用于创建一个负责"删除"操作的Command对象并返回，要搞清这个方法看似矛盾的名字里create和delete是对不同对象而言的。

有了Command和EditPolicy，现在可以来看看EditPart部分了。每一个模型对象都对应一个EditPart，所以我们的三个模型对象（Element不算）分别对应DiagramPart、ConnectionPart和NodePart。对于含有子元素的EditPart，必须覆盖getModelChildren()方法返回子对象列表，例如DiagramPart里这个方法返回的是Diagram对象包含的Node对象列表。

每个EditPart都有active()和deactive()两个方法，一般我们在前者里注册监听器（因为实现了PropertyChangeListener接口，所以EditPart本身就是监听器）到模型对象，在后者里将监听器从列表里移除。在触发监听器事件的propertyChange()方法里，一般是根据"事件名"称决定使用何种方式刷新视图，例如对于NodePart，如果是节点本身的属性发生变化，则调用refreshVisuals()方法，若是与它相关的连接发生变化，则调用refreshTargetConnections()或refreshSourceConnections()。这里用到的事件名称都是我们自己来规定的，在例子中比如Node.PROP_NAME表示节点的名称属性，Node.PROP_LOCATION表示节点的位置属性，等等。

EditPart（确切的说是AbstractGraphicalEditpart）另外一个需要实现的重要方法是createFigure()，这个方法应该返回模型在视图中的图形表示，是一个IFigure类型对象。一般都把这些图形放在figures包里，例子里只有NodeFigure一个自定义图形，Diagram对象对应的是GEF自带的名为FreeformLayer的图形，它是一个可以在东南西北四个方向任意扩展的层图形；而Connection对应的也是GEF自带的图形，名为PolylineConnection，这个图形缺省是一条用来连接另外两个图形的直线，在例子里我们通过setTargetDecoration()方法让连接的目标端显示一个箭头。

最后，要为EditPart增加适当的EditPolicy，这是通过覆盖EditPart的createEditPolicies()方法来实现的，每一个被"安装"到EditPart中的EditPolicy都对应一个用来表示角色（Role）的字符串。对于在模型中有子元素的EditPart，一般都会安装一个EditPolicy.LAYOUT_ROLE角色的EditPolicy（见下面的代码），后者多为LayoutEditPolicy的子类；对于连接类型的EditPart，一般要安装EditPolicy.CONNECTION_ENDPOINTS_ROLE角色的EditPolicy，后者则多为ConnectionEndpointEditPolicy或其子类，等等。

installEditPolicy(EditPolicy.LAYOUT_ROLE, new DiagramLayoutEditPolicy());

用户的操作会被当前工具（缺省为选择工具SelectionTool）转换为请求（Request），请求根据类型被分发到目标EditPart所安装的EditPolicy，后者根据请求对应的角色来判断是否应该创建命令并执行。

在以前的帖子里说过，Role-EditPolicy-Command这样的设计主要是为了尽量重用代码，例如同一个EditPolicy可以被安装在不同EditPart中，而同一个Command可以被不同的EditPolicy所使用，等等。当然，凡事有利必有弊，我认为这种的设计也有缺点，首先在代码上看来不够直观，你必须对众多Role、EditPolicy有所了解，增加了学习周期；另外大部分不需要重用的代码也要按照这个相对复杂的方式来写，带来了额外工作量。

以上就是一个GEF应用程序里最基本的几个组成部分，例子中还有如Direct Edit、属性表和大纲视图等一些功能没有讲解，下面的帖子里将介绍这些常用功能的实现。

原文地址：http://www.cnblogs.com/bjzhanghao/archive/2005/02/13/104045.html
在前面的帖子已经提到，GEF（Graphical Editor Framework）是一个图形化编辑框架，它允许开发人员以图形化的方式展示和编辑模型，从而提升用户体验。这样的应用程序有很多，例如：UML类图编辑器、图形化XML编辑器、界面设计工具以及图形化数据库结构设计工具等等。归结一下，可以发现它们在图形化编辑方面具有以下共同之处：

• 提供一个编辑区域和一个工具条，用户在工具条里选择需要的工具，以拖动或单击的方式将节点或连接放置在编辑区域；
• 节点可以包含子节点；
• 用户能够查看和修改某个节点或连接的大部分属性；
• 连接端点锚定在节点上；
• 提供上下文菜单和键盘命令；
• 提供图形的缩放功能；
• 提供一个大纲视图，显示编辑区域的缩略图，或是树状模型结构；
• 支持撤消/重做功能；
• 等等。

 
图1 基于GEF的界面设计工具（Visual Editor，VE）的工作界面

GEF最早是Eclipse的一个内部项目，后来逐渐转变为Eclipse的一个开源工具项目，Eclipse的不少其他子项目都需要它的支持。Eclipse 3.0版本花了很大功夫在从Platform中剥离各种功能部件上，包括GEF和IDE在内的很多曾经只能在Eclipse内部使用的工具成为可以独立使用的软件/插件包了。理论上我们是可以脱离Eclipse用GEF包构造自己的应用程序的，但由于它们之间天然的联系，而且Eclipse确实是一个很值得支持的开发平台，所以我还是推荐你在Eclipse中使用它。

GEF的优势是提供了标准的MVC（Model-View-Control）结构，开发人员可以利用GEF来完成以上这些功能，而不需要自己重新设计。与其他一些MVC编辑框架相比，GEF的一个主要设计目标是尽量减少模型和视图之间的依赖，好处是可以根据需要选择任意模型和视图的组合，而不必受开发框架的局限（不过实际上还是很少有脱离Draw2D的实现）。

现在来看看GEF是如何实现MVC框架的吧，在这个帖子里我们先概括介绍一下它的各个组成部分，以后将结合例子进行更详细的说明。

 
图2 GEF结构图

模型：GEF的模型只与控制器打交道，而不知道任何与视图有关的东西。为了能让控制器知道模型的变化，应该把控制器作为事件监听者注册在模型中，当模型发生变化时，就触发相应的事件给控制器，后者负责通知各个视图进行更新。

典型的模型对象会包含PropertyChangeSupport类型的成员变量，用来维护监听器成员即控制器；对于与其他对象具有连接关系的模型，要维护连入/连出的连接列表；如果模型对应的节点具有大小和位置信息，还要维护它们。这些变量并不是模型本身必须的信息，维护它们使模型变得不够清晰，但你可以通过构造一些抽象模型类（例如让所有具有连接的模型对象继承Node类）来维持它们的可读性。

相对来讲GEF中模型是MVC中最简单的一部分。

控制器：我们知道，在MVC结构里控制器是模型与视图之间的桥梁，也是整个GEF的核心。它不仅要监听模型的变化，当用户编辑视图时，还要把编辑结果反映到模型上。举个例子来说，用户在数据库结构图上删除一个表时，控制器应该从模型中删除这个表对象、表中的字段对象、以及与这些对象有关的所有连接。当然在GEF中这些操作不是由直接控制器完成的，这个稍后就会说到。

GEF中的控制器是所谓的EditPart对象，更确切的说应该是一组EditPart对象共同组成了GEF的控制器这部分，每一个模型对象都对应一个EditPart对象。你的应用程序中需要有一个EditPartFactory对象负责根据给定模型对象创建对应的EditPart对象，这个工厂类将被视图利用。

RootEditPart是一种特殊的EditPart，它和你的模型没有任何关系，它的作用是把EditPartViewer和contents（应用程序的最上层EditPart，一般代表一块画布）联系起来，可以把它想成是contents的容器。EditPartViewer有一个方法setRootEditPart()专门用来指定视图对应的RooEditPart。

图3 EditPart对象

用户的编辑操作被转换为一系列请求（Request），有很多种类的请求，这些种类在GEF里被称为角色（Role），GEF里有图形化和非图形化这两大类角色，前者比如Layout Role对应和布局有关的的操作，后者比如Connection Role对应和连接有关的操作等等。角色这个概念是通过编辑策略（EditPolicy）来实现的，EditPolicy的主要功能是根据请求创建相应的命令（Command），而后者会直接操作模型对象。对每一个EditPart，你都可以"安装"一些EditPolicy，用户对这个EditPart的特定操作会被交给已安装的对应EditPolicy处理。这样做的直接好处是可以在不同EditPart之间共享一些重复操作。

在GEF SDK提供的帮助文档（GEF开发指南）里有一份详细的EditPolicy、Role和Request类型列表，这里就不赘述了。

视图：前面说过，GEF的视图可以有很多种，GEF目前提供了图形（GraphicalViewer）和树状（TreeViewer）这两种，前者利用Draw2D图形（IFigure）作为表现方式，多用于编辑区域，后者则多用于实现大纲展示。视图的任务同样繁重，除了模型的显示功能以外，还要提供编辑功能、回显（Feedback）、工具提示（ToolTip）等等。

GEF使用EditPartViewer作为视图，它的作用和JFace中的Viewer十分类似，而EditPart就相当于是它的ContentProvider和LabelProvider，通过setContents()方法来指定。我们经常使用的Editor是一个GraphicalEditorWithPalette（GEF提供的Editor，是EditorPart的子类，具有图形化编辑区域和一个工具条），这个Editor使用GraphicalEditViewer和PaletteViewer这两个视图类，PaletteViewer也是GraphicalEditViewer的子类。开发人员要在configureGraphicalViewer()和initializeGraphicalViewer()这两个方法里对EditPartViewer进行定制，包括指定它的contents和EditPartFactory等等。

EditPartViewer同时也是ISelectionProvider，这样当用户在编辑区域做选择操作时，注册的SelectionChangeListener就可以收到选择事件。EditPartViewer会维护各个EditPart的选中状态，如果没有被选中的EditPart，则缺省选中的是作为contents的EditPart。

初步了解了GEF的MVC实现方式，让我们看看典型的GEF应用程序是什么样子的。大部分GEF应用程序都实现为Eclipse的Editor，也就是说整个编辑区域是放置在一个Editor里的。所以典型的GEF应用程序具有一个图形编辑区域包含在一个Editor（例如GraphicalEditorWithPalette）里，可能有一个大纲视图和一个属性页，一个用于创建EditPart实例的EditPartFactory，一些表示业务的模型对象，与模型对象对应的一些EditPart，每个EditPart对应一个IFigure的子类对象显示给用户，一些EditPolicy对象，以及一些Command对象。

GEF应用程序的工作方式如下： EditPartViewer接受用户的操作，例如节点的选择、新增或删除等等，每个节点都对应一个EditPart对象，这个对象有一组按操作Role分开的EditPolicy，每个EditPolicy会对应一些Command对象，Command最终对模型进行直接修改。用户的操作转换为Request分配给适当的EditPolicy，由后者创建适当的Command来修改模型，这些Command会保留在EditDomain（专门用于维护EditPartViewer、Command等信息的对象，一般每个Editor对应唯一一个该对象）的命令堆栈里，用于实现撤消/重做功能。

以上介绍了GEF中一些比较重要的概念，不知道看过之后你是否对它有了一个大概的印象。如果没有也没关系，因为在后面的帖子里将会有结合例子的讲解，我们使用的实例就是序言里提到的第六个项目。

参考资料：

• GEF开发指南
• Eclipse Development - Using the Graphical Editing Framework and the Eclipse Modeling Framework

原文地址：http://www.cnblogs.com/bjzhanghao/archive/2005/02/09/103595.html

鸡年第一天，首先向大家拜个年，恭祝新春快乐，万事如意。一年之计在于春，你对新的一年有什么安排呢？好的，下面还是进入正题吧。

关于Java2D相信大家都不会陌生，它是基于AWT/Swing的二维图形处理包， JDK附带的示例程序向我们展示了Java2D十分强大的图形处理能力。在Draw2D出现以前，SWT应用程序在这方面一直处于下风，而Draw2D这个SWT世界里的Java2D改变了这种形势。

可能很多人还不十分了解GEF和Draw2D的关系：一些应用程序是只使用Draw2D，看起来却和GEF应用程序具有相似的外观。原因是什么，下面先简单解释一下：

GEF是具有标准MVC（Model-View-Control）结构的图形编辑框架，其中Model由我们自己根据业务来设计，它要能够提供某种模型改变通知的机制，用来把Model的变化告诉Control层；Control层由一些EditPart实现，EditPart是整个GEF的核心部件，关于EditPart的机制和功能将在以后的帖子里介绍；而View层（大多数情况下）就是我们这里要说的Draw2D了，其作用是把Model以图形化的方式表现给使用者。

虽然GEF可以使用任何图形包作为View层，但实际上GEF对Draw2D的依赖是很强的。举例来说：虽然EditPart（org.eclipse.gef.EditPart）接口并不要求引入任何Draw2D的类，但我们最常使用的AbstractGraphicalEditPart类的createFigure()方法就需要返回IFigure类型。由于这个原因，在GEF的SDK中索性包含了Draw2D包就不奇怪了，同样道理，只有先了解Draw2D才可能掌握GEF。

这样，对于一开始提出的问题可以总结如下：Draw2D是基于SWT的图形处理包，它适合用作GEF的View层。如果一个应用仅需要显示图形，只用Draw2D就够了；若该应用的模型要求以图形化的方式被编辑，那么最好使用GEF框架。

现在让我们来看看Draw2D里都有些什么，请看下图。

图1 Draw2D的结构

Draw2D通过被称为LightweightSystem（以下简称LWS）的部件与SWT中的某一个Canvas实例相连，这个Canvas在Draw2D应用程序里一般是应用程序的Shell，在GEF应用程序里更多是某个Editor的Control（createPartControl()方法中的参数），在界面上我们虽然看不到LWS的存在，但其他所有能看到的图形都是放在它里面的，这些图形按父子包含关系形成一个树状的层次结构。

LWS是Draw2D的核心部件，它包含三个主要组成部分：RootFigure是LWS中所有图形的根，也就是说其他图形都是直接或间接放在RootFigure里的；EventDispatcher把Canvas上的各种事件分派给RootFigure，这些事件最终会被分派给适当的图形，请注意这个RootFigure和你应用程序中最顶层的IFigure不是同一个对象，前者是看不见的被LWS内部使用的，而后者通常会是一个可见的画布，它是直接放在前者中的；UpdateManager用来重绘图形，当Canvas被要求重绘时，LWS会调用它的performUpdate()方法。

LWS是连接SWT和Draw2D的桥梁，利用它，我们不仅可以轻松创建任意形状的图形（不仅仅限于矩形），同时能够节省系统资源（因为是轻量级组件）。一个典型的纯Draw2D应用程序代码具有类似下面的结构：

//创建SWT的Canvas（Shell是Canvas的子类）
Shell shell = new Shell();
shell.open();
shell.setText("A Draw2d application");
//创建LightweightSystem，放在shell上
LightweightSystem lws = new LightweightSystem(shell);
//创建应用程序中的最顶层图形
IFigure panel = new Figure();
panel.setLayoutManager(new FlowLayout());
//把这个图形放置于LightweightSystem的RootFigure里
lws.setContents(panel); 

//创建应用程序中的其他图形，并放置于应用程序的顶层图形中
panel.add();
while (!shell.isDisposed ()) {
if (!display.readAndDispatch ())
   display.sleep ();
}

接下来说说图形，Draw2D中的图形全部都实现IFigure（org.eclipse.draw2d.IFigure）接口，这些图形不仅仅是你看到的屏幕上的一块形状而已，除了控制图形的尺寸位置以外，你还可以监听图形上的事件（鼠标事件、图形结构改变等等，来自LWS的EventDispatcher）、设置鼠标指针形状、让图形变透明、聚焦等等，每个图形甚至还拥有自己的Tooltip，十分的灵活。

Draw2D提供了很多缺省图形，最常见的有三类：1、形状（Shape），如矩形、三角形、椭圆形等等；2、控件（Widget），如标签、按钮、滚动条等等；3、层（Layer），它们用来为放置于其中的图形提供缩放、滚动等功能，在3.0版本的GEF中，还新增了GridLayer和GuideLayer用来实现"吸附到网格"功能。在以IFigure为根节点的类树下有相当多的类，不过我个人感觉组织得有些混乱，幸好大部分情况下我们只用到其中常用的那一部分。

图2 一个Draw2D应用程序

每个图形都可以拥有一个边框（Border），Draw2D所提供的边框类型有GroupBoxBorder、TitleBarBorder、ImageBorder、ButtonBorder，以及可以组合两种边框的CompoundBorder等等，在Draw2D里还专门有一个Insets类用来表示边框在图形中所占的位置，它包含上下左右四个整型数值。

我们知道，一个图形可以包含很多个子图形，这些被包含的图形在显示的时候必须以某种方式被排列起来，负责这个任务的就是父图形的LayoutManager。同样的，Draw2D已经为我们提供了一系列可以直接使用的LayoutManager，如FlowLayout适合用于表格式的排列，XYLayout适合让用户在画布上用鼠标随意改变图形的位置，等等。如果没有适合我们应用的LayoutManager，可以自己定制。每个LayoutManager都包含某种算法，该算法将考虑与每个子图形关联的Constraint对象，计算得出子图形最终的位置和大小。

图形化应用程序的一个常见任务就是在两个图形之间做连接，想象一下UML类图中的各种连接线，或者程序流程图中表示数据流的线条，它们有着不同的外观，有些连接线还要显示名称，而且最好能不交叉。利用Draw2D中的Router、Anchor和Locator，可以实现多种连接样式，其中Router负责连接线的外观和操作方式，最简单的是设置Router为null（无Router），这样会使用直线连接，其他连接方式包括折线、具有控制点的折线等等（见图3），若想控制连接线不互相交叉也需要在Router中作文章。Anchor控制连接线端点在图形上的位置，即"锚点"的位置，最易于使用的是ChopBoxAnchor，它先假设图形中心为连接点，然后计算这条假想连线与图形边缘的交汇点作为实际的锚点，其他Anchor还有EllipseAnchor、LabelAnchor和XYAnchor等等；最后，Locator的作用是定位图形，例如希望在连接线中点处以一个标签显示此连线的名称/作用，就可以使用MidpointLocator来帮助定位这个标签，其他Locator还有ArrowLocator用于定位可旋转的修饰（Decoration，例如PolygonDecoration）、BendpointerLocator用于定位连接控制点、ConnectionEndpointLocator用于定位连接端点（通过指定uDistance和vDistance属性的值可以设置以端点为原点的坐标）。

图3 三种Router的外观

此外，Draw2D在org.eclipse.draw2d.geometry包里提供了几个很方便的类型，如Dimension、Rectangle、Insets、Point和PointList等等，这些类型既在Draw2D内部广泛使用，也可以被开发人员用来简化计算。例如Rectangle表示的是一个矩形区域，它提供getIntersection()方法能够方便的计算该区域与另一矩形区域的重叠区域、getTransposed()方法可以得到长宽值交换后的矩形区域、scale()方法进行矩形的拉伸等等。在自己实现LayoutManager的时候，由于会涉及到比较复杂的几何计算，所以更推荐使用这些类。

以上介绍了Draw2D提供的大部分功能，利用这些我们已经能够画出十分漂亮的图形了。但对大多数实际应用来说这样还远远不够，我们还要能编辑它，并把对图形的修改反映到模型里去。为了漂亮的完成这个艰巨任务，GEF绝对是不二之选。从下一次开始，我们将正式进入GEF的世界。

参考资料：

• GEF Developer Guide
• Eclipse Development - Using the Graphical Editing Framework and the Eclipse Modeling Framework
• Displaying a UML Diagram with Draw2D

　　当然这些都是Java的基本题，那些面试的人大多数不会问你Hibernate有多先进，Eclipse的三个组成部分，或command design pattern，他们都是老一辈了，最喜欢问的就是基础知识。别小看了这些基础，我朋友水平一流，结果就栽在一到基础知识的问题下，和高薪无缘。

　　好了废话少说，开始正题。

问：

第一，谈谈final, finally, finalize的区别。

最常被问到。

第二，Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

第三，Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼统)。

第四，&和&&的区别。

这个问得很少。

第五，HashMap和Hashtable的区别。

常问。

第六，Collection 和 Collections的区别。

你千万别说一个是单数一个是复数。

第七，什么时候用assert。

API级的技术人员有可能会问这个。

第八，GC是什么? 为什么要有GC?

基础。

第九，String s = new String("xyz");创建了几个String Object?

第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

第十一，short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

面试题都是很变态的，要做好受虐的准备。

第十二，sleep() 和 wait() 有什么区别?

搞线程的最爱。

第十三，Java有没有goto?

很十三的问题，如果哪个面试的问到这个问题，我劝你还是别进这家公司。

第十四，数组有没有length()这个方法? String有没有length()这个方法?

第十五，Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

常问。

第十六，Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?

第十七，给我一个你最常见到的runtime exception。

如果你这个答不出来，面试的人会认为你没有实际编程经验。

第十八，error和exception有什么区别?

第十九，List, Set, Map是否继承自Collection接口?

第二十，abstract class和interface有什么区别?

常问。

第二十一，abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?

第二十二，接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

第二十三，启动一个线程是用run()还是start()?

第二十四，构造器Constructor是否可被override?

第二十五，是否可以继承String类?

第二十六，当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

第二十七，try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?

第二十八，编程题: 用最有效率的方法算出2乘以8等於几?

有C背景的程序员特别喜欢问这种问题。

第二十九，两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?

第三十，当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?

第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?

第三十二，编程题: 写一个Singleton出来

好先说这么一些。

答：

第一，谈谈final, finally, finalize的区别。

　　final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。

　　finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。

　　finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

第二，Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

　　匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。

第三，Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼统)。

　　Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。具体可见http: //www.frontfree.net/articles/services/view.asp?id=704&page=1

　　注： 静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

第四，&和&&的区别。

　　&是位运算符。&&是布尔逻辑运算符。

第五，HashMap和Hashtable的区别。

　　都属于Map接口的类，实现了将惟一键映射到特定的值上。

　　HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。

　　Hashtable 类似于 HashMap，但是不允许 null 键和 null 值。它也比 HashMap 慢，因为它是同步的。

第六，Collection 和 Collections的区别。

　　Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。

　　Collection是个java.util下的接口，它是各种集合结构的父接口。

第七，什么时候用assert。

　　断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true。如果表达式计算为 false，那么系统会报告一个 Assertionerror。它用于调试目的：

assert(a > 0); // throws an Assertionerror if a <= 0

断言可以有两种形式：

assert Expression1 ;
assert Expression1 : Expression2 ;

　　Expression1 应该总是产生一个布尔值。

　　Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 String 消息。

　　断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记：

　　javac -source 1.4 Test.java

　　要在运行时启用断言，可使用 -enableassertions 或者 -ea 标记。

　　要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。

　　要系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用断言。

　　可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。

第八，GC是什么? 为什么要有GC? (基础)。

　　GC是垃圾收集器。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：

System.gc()
Runtime.getRuntime().gc()

第九，String s = new String("xyz");创建了几个String Object?

　　两个对象，一个是“xyx”,一个是指向“xyx”的引用对象s。

第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

　　Math.round(11.5)返回（long）12，Math.round(-11.5)返回（long）-11;

第十一，short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

　　short s1 = 1; s1 = s1 + 1;有错，s1是short型，s1+1是int型,不能显式转化为short型。可修改为s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正确。

第十二，sleep() 和 wait() 有什么区别? 搞线程的最爱

　　sleep()方法是使线程停止一段时间的方法。在sleep 时间间隔期满后，线程不一定立即恢复执行。这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行，除非(a)“醒来”的线程具有更高的优先级 (b)正在运行的线程因为其它原因而阻塞。

　　wait()是线程交互时，如果线程对一个同步对象x 发出一个wait()调用，该线程会暂停执行，被调对象进入等待状态，直到被唤醒或等待时间到。

第十三，Java有没有goto?

　　Goto—java中的保留字，现在没有在java中使用。

第十四，数组有没有length()这个方法? String有没有length()这个方法？

　　数组没有length()这个方法，有length的属性。

　　String有有length()这个方法。

第十五，Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

　　方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

第十六，Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?

　　Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。

　　equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

第十七，给我一个你最常见到的runtime exception。

ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, ClassCastException, CMMException, ConcurrentModificationException, DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException,
ImagingOpException, IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException, NoSuchElementException, NullPointerException, ProfileDataException, ProviderException, RasterFORMatException, SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException

第十八，error和exception有什么区别?

　　error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。

　　exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

第十九，List, Set, Map是否继承自Collection接口?

List，Set是

Map不是

第二十，abstract class和interface有什么区别?

　　声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

　　接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

第二十一，abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?

　　都不能

第二十二，接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

　　接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。

第二十三，启动一个线程是用run()还是start()?

　　启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

第二十四，构造器Constructor是否可被override?

　　构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。

第二十五，是否可以继承String类?

　　String类是final类故不可以继承。

第二十六，当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

　　不能，一个对象的一个synchronized方法只能由一个线程访问。

第二十七，try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?

　　会执行，在return前执行。

第二十八，编程题: 用最有效率的方法算出2乘以8等於几?

　　有C背景的程序员特别喜欢问这种问题。

　　2 << 3

第二十九，两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?

　　不对，有相同的hash code。

第三十，当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?

　　是值传递。Java 编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?

　　switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。

第三十二，编程题: 写一个Singleton出来。

　　Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

　　一般Singleton模式通常有几种种形式：

　　第一种形式：定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

public class Singleton {
　　private Singleton(){}
　　//在自己内部定义自己一个实例，是不是很奇怪？
　　//注意这是private 只供内部调用
　　private static Singleton instance = new Singleton();
　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 }
}

　　第二种形式：

public class Singleton {
　　private static Singleton instance = null;
　　public static synchronized Singleton getInstance() {
　　//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　 　
　　//使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance＝new Singleton();
return instance; 　　}
}

其他形式：

　　定义一个类，它的构造函数为private的，所有方法为static的。

　　一般认为第一种形式要更加安全些

　　Hashtable和HashMap

　　Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现

　　HashMap允许将null作为一个entry的key或者value，而Hashtable不允许

　　还有就是，HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。

　　最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在
多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap
就必须为之提供外同步。

　　Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异

Java的一个重要优点就是通过垃圾收集器(Garbage Collection，GC)自动管理内存的回收，程序员不需要通过调用函数来释放内存。因此，很多程序员认为Java不存在内存泄漏问题，或者认为即使有内存泄漏也不是程序的责任，而是GC或JVM的问题。其实，这种想法是不正确的，因为Java也存在内存泄露，但它的表现与C++不同。

随着越来越多的服务器程序采用Java技术，例如JSP，Servlet， EJB等，服务器程序往往长期运行。另外，在很多嵌入式系统中，内存的总量非常有限。内存泄露问题也就变得十分关键，即使每次运行少量泄漏，长期运行之后，系统也是面临崩溃的危险。

二 Java是如何管理内存

为了判断Java中是否有内存泄露，我们首先必须了解Java是如何管理内存的。Java的内存管理就是对象的分配和释放问题。在Java中，程序员需要通过关键字new为每个对象申请内存空间 (基本类型除外)，所有的对象都在堆 (Heap)中分配空间。另外，对象的释放是由GC决定和执行的。在Java中，内存的分配是由程序完成的，而内存的释放是有GC完成的，这种收支两条线的方法确实简化了程序员的工作。但同时，它也加重了JVM的工作。这也是Java程序运行速度较慢的原因之一。因为，GC为了能够正确释放对象，GC必须监控每一个对象的运行状态，包括对象的申请、引用、被引用、赋值等，GC都需要进行监控。

监视对象状态是为了更加准确地、及时地释放对象，而释放对象的根本原则就是该对象不再被引用。

为了更好理解GC的工作原理，我们可以将对象考虑为有向图的顶点，将引用关系考虑为图的有向边，有向边从引用者指向被引对象。另外，每个线程对象可以作为一个图的起始顶点，例如大多程序从main进程开始执行，那么该图就是以main进程顶点开始的一棵根树。在这个有向图中，根顶点可达的对象都是有效对象，GC将不回收这些对象。如果某个对象 (连通子图)与这个根顶点不可达(注意，该图为有向图)，那么我们认为这个(这些)对象不再被引用，可以被GC回收。

以下，我们举一个例子说明如何用有向图表示内存管理。对于程序的每一个时刻，我们都有一个有向图表示JVM的内存分配情况。以下右图，就是左边程序运行到第6行的示意图。

Java使用有向图的方式进行内存管理，可以消除引用循环的问题，例如有三个对象，相互引用，只要它们和根进程不可达的，那么GC也是可以回收它们的。这种方式的优点是管理内存的精度很高，但是效率较低。另外一种常用的内存管理技术是使用计数器，例如COM模型采用计数器方式管理构件，它与有向图相比，精度行低(很难处理循环引用的问题)，但执行效率很高。

三 什么是Java中的内存泄露

下面，我们就可以描述什么是内存泄漏。在Java中，内存泄漏就是存在一些被分配的对象，这些对象有下面两个特点，首先，这些对象是可达的，即在有向图中，存在通路可以与其相连；其次，这些对象是无用的，即程序以后不会再使用这些对象。如果对象满足这两个条件，这些对象就可以判定为Java中的内存泄漏，这些对象不会被GC所回收，然而它却占用内存。

在C++中，内存泄漏的范围更大一些。有些对象被分配了内存空间，然后却不可达，由于C++中没有GC，这些内存将永远收不回来。在Java中，这些不可达的对象都由GC负责回收，因此程序员不需要考虑这部分的内存泄露。

通过分析，我们得知，对于C++，程序员需要自己管理边和顶点，而对于Java程序员只需要管理边就可以了(不需要管理顶点的释放)。通过这种方式，Java提高了编程的效率。

因此，通过以上分析，我们知道在Java中也有内存泄漏，但范围比C++要小一些。因为Java从语言上保证，任何对象都是可达的，所有的不可达对象都由GC管理。

对于程序员来说，GC基本是透明的，不可见的。虽然，我们只有几个函数可以访问GC，例如运行GC的函数System.gc()，但是根据Java语言规范定义， 该函数不保证JVM的垃圾收集器一定会执行。因为，不同的JVM实现者可能使用不同的算法管理GC。通常，GC的线程的优先级别较低。JVM调用GC的策略也有很多种，有的是内存使用到达一定程度时，GC才开始工作，也有定时执行的，有的是平缓执行GC，有的是中断式执行GC。但通常来说，我们不需要关心这些。除非在一些特定的场合，GC的执行影响应用程序的性能，例如对于基于Web的实时系统，如网络游戏等，用户不希望GC突然中断应用程序执行而进行垃圾回收，那么我们需要调整GC的参数，让GC能够通过平缓的方式释放内存，例如将垃圾回收分解为一系列的小步骤执行，Sun提供的HotSpot JVM就支持这一特性。

下面给出了一个简单的内存泄露的例子。在这个例子中，我们循环申请Object对象，并将所申请的对象放入一个Vector中，如果我们仅仅释放引用本身，那么Vector仍然引用该对象，所以这个对象对GC来说是不可回收的。因此，如果对象加入到Vector后，还必须从Vector中删除，最简单的方法就是将Vector对象设置为null。

Vector v=new Vector(10);
for (int i=1;i<100; i++)
{
Object o=new Object();
v.add(o);
o=null;
}
//此时，所有的Object对象都没有被释放，因为变量v引用这些对象。

四 如何检测内存泄漏

最后一个重要的问题，就是如何检测Java的内存泄漏。目前，我们通常使用一些工具来检查Java程序的内存泄漏问题。市场上已有几种专业检查Java内存泄漏的工具，它们的基本工作原理大同小异，都是通过监测Java程序运行时，所有对象的申请、释放等动作，将内存管理的所有信息进行统计、分析、可视化。开发人员将根据这些信息判断程序是否有内存泄漏问题。这些工具包括Optimizeit Profiler，JProbe Profiler，JinSight , Rational 公司的Purify等。

下面，我们将简单介绍Optimizeit的基本功能和工作原理。

Optimizeit Profiler版本4.11支持Application，Applet，Servlet和Romote Application四类应用，并且可以支持大多数类型的JVM，包括SUN JDK系列，IBM的JDK系列，和Jbuilder的JVM等。并且，该软件是由Java编写，因此它支持多种操作系统。Optimizeit系列还包括Thread Debugger和Code Coverage两个工具，分别用于监测运行时的线程状态和代码覆盖面。

当设置好所有的参数了，我们就可以在OptimizeIt环境下运行被测程序，在程序运行过程中，Optimizeit可以监视内存的使用曲线(如下图)，包括JVM申请的堆(heap)的大小，和实际使用的内存大小。另外，在运行过程中，我们可以随时暂停程序的运行，甚至强行调用GC，让GC进行内存回收。通过内存使用曲线，我们可以整体了解程序使用内存的情况。这种监测对于长期运行的应用程序非常有必要，也很容易发现内存泄露。

在运行过程中，我们还可以从不同视角观查内存的使用情况，Optimizeit提供了四种方式：

• 堆视角。 这是一个全面的视角，我们可以了解堆中的所有的对象信息(数量和种类)，并进行统计、排序，过滤。了解相关对象的变化情况。
• 方法视角。通过方法视角，我们可以得知每一种类的对象，都分配在哪些方法中，以及它们的数量。
• 对象视角。给定一个对象，通过对象视角，我们可以显示它的所有出引用和入引用对象，我们可以了解这个对象的所有引用关系。
• 引用图。 给定一个根，通过引用图，我们可以显示从该顶点出发的所有出引用。

在运行过程中，我们可以随时观察内存的使用情况，通过这种方式，我们可以很快找到那些长期不被释放，并且不再使用的对象。我们通过检查这些对象的生存周期，确认其是否为内存泄露。在实践当中，寻找内存泄露是一件非常麻烦的事情，它需要程序员对整个程序的代码比较清楚，并且需要丰富的调试经验，但是这个过程对于很多关键的Java程序都是十分重要的。

综上所述，Java也存在内存泄露问题，其原因主要是一些对象虽然不再被使用，但它们仍然被引用。为了解决这些问题，我们可以通过软件工具来检查内存泄露，检查的主要原理就是暴露出所有堆中的对象，让程序员寻找那些无用但仍被引用的对象。