日本婷婷久久久久久久久一区二区,自拍亚洲一区,动漫h在线观看

设计模式的原�?�?

黑石 — Mon, 26 Dec 2005 07:45:00 GMT

�q�年来，大家都开始注意设计模式。那么，到底我们��Z��么要用设计模式呢�Q�这么多设计模式��Z��么要�q�么设计呢？说实话，以前我还真没搞清楚。就是看大家一口一�?Design pattern"�Q�心��有点发虚。于是就��C��?四�h�?的设计模式，�l�果看得似懂非懂:看得时候好像是懂了�Q�过一会就忘了。可能是本�h比较"愚钝"�?))最�q�，有了�Ҏ��悟�?独乐不如众乐"�Q�与大家分��n一下，�q�望指教!
��Z��么要提�?Design Pattern"呢？�Ҏ��原因是�ؓ了代码复用，增加可维护性。那么怎么才能实现代码复用呢？OO界有前辈的几个原则："开�Q�闭"原则(Open Closed Principal)、里氏代换原则、合成复用原则。设计模式就是实��C��q�些原则�Q�从而达��C��代码复用、增加可�l�护性的目的�?BR>

一�?开�Q�闭"原则

    此原则是�?Bertrand Meyer"提出的。原文是�Q?Software entities should be open for extension,but closed for modification"。就是说模块应对扩展开放，而对修改关闭。模块应��量在不修改�?�?�?�Q�指原来的代�?代码的情况下�q�行扩展。那么怎么扩展呢？我们看工厂模�?factory pattern":假设中关村有一个卖盗版盘和毛片的小子，我们�l�他设计一"光盘销售管理��Y�?。我们应该先设计一"光盘"接口。如图：
[pre]______________
|<>|
| 光盘        |
|_____________|
|+�?)        |
|             |
|_____________|[/pre]
而盗版盘和毛片是其子�c�R��小子通过"DiscFactory"来管理这些光盘。代码�ؓ�Q?BR>

public class DiscFactory{
public static 光盘 getDisc(String name){
return (光盘)Class.forName(name).getInstance();
}
}

有�h要买盗版盘，怎么实现呢？

public class ��子{
public static void main(String[] args){
光盘 d=DiscFactory.getDisc("盗版�?);
光盘.�?);
}
}

如果有一天，�q�小子良心发��C��Q�开始卖正版软�g。没关系�Q�我们只要再创徏一�?光盘"的子�c?正版软�g"��可以了。不需要修改原�l�构和代码。怎么��P��Ҏ��展开发，对修改关闭�?开-闭原�?
工厂模式是对具体产品�q�行扩展�Q�有的项目可能需要更多的扩展性，要对�q�个"工厂"也进行扩展，那就成了"抽象工厂模式"�?BR>

    二、里氏代换原�?/H3>
里氏代换原则是由"Barbara Liskov"提出的。如果调用的是父�cȝ��话，那么换成子类也完全可以运行。比如：
       光盘 d=new 盗版�?);
       d.�?);
    现在要将"盗版�?�c�L��?毛片"�c�，没问题，完全可以�q�行。Java�~�译�E�序会检查程序是否符合里氏代换原则。还记得java�l�承的一个原则吗�Q�子�c�overload�Ҏ��的访问权限不能小于父�c�d��应方法的讉K��权限。比�?光盘"中的�Ҏ��"�?讉K��权限�?public"�Q�那�?盗版�?�?毛片"中的"�?�Ҏ��׃��能是package或private�Q�编译不能通过。�ؓ什么要�q�样呢？你想啊：如果"盗版�?�?�?�Ҏ��是private。那么下面这�D�代码就不能执行了：
            光盘 d=new 盗版�?);
            d.�?);
可以��_��里氏代换原则是��承复用的一个基��?BR>

    三、合成复用原�?/H3>
    ��是说要��用�l�承�Q�多用合成关�p�L��实现。我曄��q�样写过�E�序�Q�有几个�c�要与数据库打交道，��写了一个数据库操作的类�Q�然后别的跟数据库打交道的类都��承这个。结果后来，我修改了数据库操作类的一个方法，各个�c�都需要改动�?牵一发而动全��n"!面向对象是要把�L动限制在��量��的范围�?BR>

    在Java中，应尽量针对Interface�~�程�Q�而非实现�c�R��这��P��更换子类不会影响调用它方法的代码。要让各个类��可能少的跟别�h联系�Q?不要与陌生�h说话"。这��P��城门��q��Q�才不至于殃及池鱹{��扩展性和�l�护性才能提�?BR>
    理解了这些原则，再看设计模式�Q�只是在具体问题上怎么实现�q�些原则而已。张无忌学太极拳�Q�忘��C��所有招式，打倒了"玄幂二�?�Q�所�?心中无招"。设计模式可谓招敎ͼ�如果先学通了各种模式�Q�又忘掉了所有模式而随心所��Ԍ��可谓OO之最高境界。呵呵，搞笑�Q�搞�W�！

�q�是我的一点心得，大家可能理解得更深刻。还望指教！

我的�|�站:http://albert.mycool.net
参考图书：《设计模式》、《Java与模式�?img src ="http://www.aygfsteel.com/fjq639/aggbug/25447.html" width = "1" height = "1" />

黑石 2005-12-26 15:45 发表评论

黑石 — Thu, 22 Dec 2005 07:42:00 GMT

本文重在Java中异常机制的一些概��c��写本文的目的在于方便我很长旉��后若是忘了这些东西可以通过�q�片文章�q�速回忆�v来�?/P>

1. 异常机制
1.1 异常机制是指当程序出现错误后�Q�程序如何处理。具体来��_��异常机制提供了程序退出的安全通道。当出现错误后，�E�序执行的流�E�发生改变，�E�序的控制权转移到异常处理器�?BR>1.2 传统的处理异常的办法是，函数�q�回一个特�D�的�l�果来表�C�出现异常（通常�q�个�Ҏ��l�果是大家约定俗�U�的�Q�，调用该函数的�E�序负责��查�ƈ分析函数�q�回的结果。这样做有如下的弊端�Q�例如函数返�?1代表出现异常�Q�但是如果函数确实要�q�回-1�q�个正确的值时��׃��出现��h��Q�可��L��降低，��程序代码与处理异常的代码�؜爹在一��P��p��用函数的�E�序来分析错误，�q�就要求客户�E�序员对库函数有很深的了解�?BR>1.3 异常处理的流�E?BR>1.3.1 遇到错误�Q�方法立即结束，�q�不�q�回一个��|��同时�Q�抛��Z��个异常对�?BR>1.3.2 调用该方法的�E�序也不会��l�执行下去，而是搜烦一个可以处理该异常的异常处理器�Q��ƈ执行其中的代�?/P>

2 异常的分�c?BR>2.1 异常的分�c?BR>2.1.1 异常的��承结构：基类为Throwable�Q�Error和Exception�l�承Throwable�Q�RuntimeException和IOException�{��承Exception�Q�具体的RuntimeException�l�承RuntimeException�?BR>2.1.2 Error和RuntimeException及其子类成�ؓ未检查异常（unchecked�Q�，其它异常成�ؓ已检查异常（checked�Q��?BR>2.2 每个�c�d��的异常的特点
2.2.1 Error体系
Error�c�M��p�L��q�C��Java�q�行�pȝ��中的内部错误以及资源耗尽的情形。应用程序不应该抛出�q�种�c�d��的对象（一般是��p��拟机抛出�Q�。如果出现这�U�错误，除了��力使程序安全退出外�Q�在其他斚w��是无能�ؓ力的。所以，在进行程序设计时�Q�应该更��x��Exception体系�?BR>2.2.2 Exception体系
Exception体系包括RuntimeException体系和其他非RuntimeException的体�p?BR>2.2.2.1 RuntimeException
RuntimeException体系包括错误的类型�{换、数�l�越界访问和试图讉K��I�指针等�{�。处理RuntimeException的原则是�Q�如果出现RuntimeException�Q�那么一定是�E�序员的错误。例如，可以通过��查数�l�下标和数组边界来避免数�l�越界访问异常�?BR>2.2.2.2 其他�Q�IOException�{�等�Q?BR>�q�类异常一般是外部错误�Q�例如试图从文�g��֐��d��数据�{�，�q��ƈ不是�E�序本��n的错误，而是在应用环境中出现的外部错误�?BR>2.3 与C++异常分类的不�?BR>2.3.1 其实�Q�Java中RuntimeException�q�个�c�d��L��q�不恰当�Q�因��Z�Q何异帔R��是运行时出现的。（在编译时出现的错误�ƈ不是异常�Q�换句话��_��异常��是��Z��解决�E�序�q�行时出现的的错误）�?BR>2.3.2 C++中logic_error与Java中的RuntimeException是等��L��Q�而runtime_error与Java中非RuntimeException�c�d��的异常是�{��h的�?/P>

3 异常的��用方�?BR>3.1 声明�Ҏ��抛出异常
3.1.1 语法�Q�throws�Q�略�Q?BR>3.1.2 ��Z��么要声明�Ҏ��抛出异常�Q?BR>�Ҏ��是否抛出异常与方法返回值的�c�d��一样重要。假设方法抛出异常确没有声明该方法将抛出异常�Q�那么客��L��序员可以调用�q�个�Ҏ��而且不用�~�写处理异常的代码。那么，一旦出现异常，那么�q�个异常��没有合适的异常控制器来解决�?BR>3.1.3 ��Z��么抛出的异常一定是已检查异常？
RuntimeException与Error可以在�Q何代码中产生�Q�它们不需要由�E�序员显�C�的抛出�Q�一旦出现错误，那么相应的异�怼�被自动抛出。而已��查异常是��q��序员抛出的，�q�分��Z��U�情况：客户�E�序员调用会抛出异常的库函数�Q�库函数的异常由库程序员抛出�Q�；客户�E�序员自�׃��用throw语句抛出异常。遇到Error�Q�程序员一般是无能为力的；遇到RuntimeException�Q�那么一定是�E�序存在逻辑错误�Q�要对程序进行修改（相当于调试的一�U�方法）�Q�只有已��查异常才是程序员所兛_��的，�E�序应该且仅应该抛出或处理已��查异常�?BR>3.1.4 注意�Q�覆盖父�c�L��Ҏ��的子�c�L��法不能抛出比父类�Ҏ��更多的异常，所以，有时设计父类的方法时会声明抛出异常，但实际的实现�Ҏ��的代码却�q�不抛出异常�Q�这样做的目的就是�ؓ了方便子�c�L��法覆盖父�c�L��法时可以抛出异常�?BR>3.2 如何抛出异常
3.2.1 语法�Q�throw�Q�略�Q?BR>3.2.2 抛出什么异常？
对于一个异常对象，真正有用的信息时异常的对象类型，而异常对象本�w�毫无意义。比如一个异常对象的�c�d��是ClassCastException�Q�那么这个类名就是唯一有用的信息。所以，在选择抛出什么异常时�Q�最关键的就是选择异常的类名能够明��说明异常情�늚��c�R�?BR>3.2.3 异常对象通常有两�U�构造函敎ͼ�一�U�是无参数的构造函敎ͼ�另一�U�是带一个字�W�串的构造函敎ͼ��q�个字符串将作�ؓ�q�个异常对象除了�c�d��名以外的额外说明�?BR>3.2.4 创徏自己的异常：当Java内置的异帔R��不能明确的说明异常情�늚�时候，需要创��q��异常。需要注意的是，唯一有用的就是类型名�q�个信息�Q�所以不要在异常�cȝ��设计上花费精力�?BR>3.3 捕获异常
如果一个异常没有被处理�Q�那么，对于一个非囑�Ş界面的程序而言�Q�该�E�序会被中止�q�输出异�怿�息；对于一个图形界面程序，也会输出异常的信息，但是�E�序�q�不中止�Q�而是�q�回用户界面处理循环中�?BR>3.3.1 语法�Q�try、catch和finally�Q�略�Q?BR>控制器模块必��ȝ��接在try块后面。若掷出一个异常，异常控制机制会搜��d��C��异常�c�d��相符的第一个控制器随后它会�q�入那个catch 从句�Q��ƈ认�ؓ异常已得到控制。一旦catch 从句�l�束�Ҏ��制器的搜索也会停止�?BR>3.3.1.1 捕获多个异常�Q�注意语法与捕获的顺序）�Q�略�Q?BR>3.3.1.2 finally的用法与异常处理��程�Q�略�Q?BR>3.3.2 异常处理做什么？
对于Java来说�Q�由于有了垃圾收集，所以异常处理�ƈ不需要回收内存。但是依然有一些资源需要程序员来收集，比如文�g、网�l�连接和囄��{�资源�?BR>3.3.3 应该声明�Ҏ��抛出异常�q�是在方法中捕获异常�Q?BR>原则�Q�捕捉�ƈ处理哪些知道如何处理的异常，而传递哪些不知道如何处理的异�?BR>3.3.4 再次抛出异常
3.3.4.1 ��Z��么要再次抛出异常�Q?BR>在本�U�中�Q�只能处理一部分内容�Q�有些处理需要在更高一�U�的环境中完成，所以应该再�ơ抛出异常。这样可以��每��的异常处理器处理它能够处理的异常�?BR>3.3.4.2 异常处理��程
对应与同一try块的catch块将被忽略，抛出的异常将�q�入更高的一�U��?/P>

4 关于异常的其他问�?BR>4.1 �q�度使用异常
首先�Q��用异常很方便�Q�所以程序员一般不再愿意编写处理错误的代码�Q�而仅仅是��单单的抛��Z��个异常。这样做是不对的�Q�对于完全已知的错误�Q�应该编写处理这�U�错误的代码�Q�增加程序的鲁棒性。另外，异常机制的效率很差�?BR>4.2 ��异�怸�普通错误区分开
对于普通的完全一致的错误�Q�应该编写处理这�U�错误的代码�Q�增加程序的鲁棒性。只有外部的不能��定和预知的�q�行旉��误才需要��用异常�?BR>4.3 异常对象中包含的信息
一般情况下�Q�异常对象唯一有用的信息就是类型信息。但使用异常带字�W�串的构造函数时�Q�这个字�W�串�q�可以作为额外的信息。调用异常对象的getMessage()、toString()或者printStackTrace()�Ҏ��可以分别得到异常对象的额外信息、类名和调用堆栈的信息。�ƈ且后一�U�包含的信息是前一�U�的��集�?/P>

黑石 2005-12-22 15:42 发表评论

黑石 — Wed, 21 Dec 2005 09:42:00 GMT

一.�q�接oracle数据�?BR>    Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
    String url="jdbc:oracle:thin:@服务器ip:1521:数据库名�U?;
    Connection conn=DriverManager.getConnection(url,"用户�?,"密码");

�?�q�接mssql数据�?BR>
     �q�接驱动文�gjtds-0.6.jar

     String url="jdbc:jtds:sqlserver://localhost:1433/‘数据库名�?�Q?
     自带驱动:

     Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();
     String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=pubs";

�?�q�接DB2数据�?BR>     Class.forName("com.ibm.db2.jdbc.app.DB2Driver ").newInstance();
     String url="jdbc:db2://localhost:5000/数据库名�U?;
四、jsp�q�接Informix数据�?BR>
      Class.forName("com.informix.jdbc.IfxDriver").newInstance();
      String url = "jdbc:informix-sqli://123.45.67.89:1533/testDB:INFORMIXSERVER=myserver;
      user=testuser;password=testpassword";
     //testDB��Z��的数据库�?
     Connection conn= DriverManager.getConnection(url);
     Statement stmt=conn.createStatement

五、jsp�q�接Sybase数据�?

    Class.forName("com.sybase.jdbc.SybDriver").newInstance();
   String url =" jdbc:sybase:Tds:localhost:5007/tsdata";
   //tsdata��Z��的数据库�?
   Properties sysProps = System.getProperties();
   SysProps.put("user","userid");
   SysProps.put("password","user_password");
   Connection conn= DriverManager.getConnection(url, SysProps);

六、jsp�q�接MySQL数据�?nbsp;
       Class.forName("org.gjt.mm.mysql.Driver").newInstance();
      String url ="jdbc:mysql://localhost/softforum?

      user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1"
    //testDB��Z��的数据库�?
     Connection conn= DriverManager.getConnection(url);

未完待箋....

黑石 2005-12-21 17:42 发表评论

JVM内存��试

黑石 — Wed, 21 Dec 2005 08:26:00 GMT

例子下蝲
默认的java虚拟机的大小比较��，在对大数据进行处理时java��׃��报错�Q�java.lang.OutOfMemoryError�?/P>

讄��jvm内存的方法，对于单独�?class�Q�可以用下面的方法对Test�q�行时的jvm内存�q�行讄��?BR>java -Xms64m -Xmx256m Test

默认的java虚拟机的大小比较��，在对大数据进行处理时java��׃��报错�Q�java.lang.OutOfMemoryError�?/P>

讄��jvm内存的方法，对于单独�?class�Q�可以用下面的方法对Test�q�行时的jvm内存�q�行讄��?BR>java -Xms64m -Xmx256m Test
-Xms是设�|�内存初始化的大��?BR>-Xmx是设�|�最大能够��用内存的大小�Q�最好不要超�q�物理内存大��）

在weblogic中，可以在startweblogic.cmd中对每个domain虚拟内存的大��进行设�|�，默认的设�|�是在commEnv.cmd里面�?/P>

黑石 2005-12-21 16:26 发表评论

�?Java 的注释上做文�?�?

黑石 — Wed, 21 Dec 2005 04:15:00 GMT

　　前言
　　一. Java 文��?javadoc
　　 �? 文档注释的格�?BR>　　　　 1. 文��注释的格式化
　　　　 2. 文��注释的三部分
　　 �? 使用 javadoc 标记
　　　　 http://outinn.diy.myrice.com/book/javadoc/#t31
　　　　 http://outinn.diy.myrice.com/book/javadoc/#t32
　　　　 http://outinn.diy.myrice.com/book/javadoc/#t33
　 �? javadoc 命��o

前言

　　Java 的语法与 C++ 及�ؓ�怼��Q�那么，你知�?Java 的注释有几种吗？是两�U�？

　　// 注释一�?BR>　　 /* ...... */ 注释若干�?/P>

　　不完全对�Q�除了以上两�U�之外，�q�有�W�三�U�，文档注释�Q?/P>

　　/** ...... */ 注释若干行，�q�写�?javadoc 文��

　　通常�q�种注释的多行写法如下：

　　/**
　　 * .........
　　 * .........
　　 */

　　暂停�Q�暂停！�q�第三种注释有什么用�Q�javadoc 又是什么东西？

　　好，那就让我告诉你—�?

一. Java 文��?javadoc

　　Java �E�序员都应该知道使用 JDK 开发，最好的帮助信息��来�?SUN 发布�?Java 文��。它分包、分�c�详�l�的提供了各�Ҏ��、属性的帮助信息�Q�具有详�l�的�c�L��信息、烦引信息等�Q��ƈ提供了许多相关类之间的关�p�，如��ѝ��实现接口、引用等�?/P>

　　Java 文档全是�׃��?html 文�g�l�织��h��的，�?SUM 的站点上可以下蝲它们的压�~�包。但是你肯定想不刎ͼ��q�些文��我们可以自己生成。——就此打住，再吊一�ơ胃口�?/P>

　　安装�?JDK 之后�Q�安装目录下有一�?src.jar 文�g或�?src.zip 文�g�Q�它们都是以 ZIP 格式压羃的，可以使用 WinZip 解压。解压之后，我们��可以看到分目录攄��全是 .java 文�g。是了，�q�些��是 Java �q�行�cȝ��源码了，非常完整�Q�连注释都写得一清二楚……不�q�，怎么看这些注释都有点似曾相识的感觉？

　　�q�就不奇怪了�Q�我们的�q�底也快要揭开了。如果你仔细�Ҏ��一�?.java 源文件中的文档注�?(/** ... */) �?Java 文档的内容，你会发现它们��是一��L��。Java 文档只是�q�在格式和排版上下了些功夫。再仔细一点，你会发现 .java 源文件中的注释还带有 HTML 标识�Q�如 �?lt;BR>�?lt;Code> �{�，�?Java 文档中，该出现这些标识的地方�Q�已�l�按标识的的定义�q�行了排版�?/P>

　　�l�于真像大白了，原来 Java 文��是来自这些注释。难怪这些注释叫做文��注释呢�Q�不�q�，是什么工��h��q�些注释变成文��的呢�Q?/P>

　　是该请出 javadoc 的时候了。在 JDK �?bin 目录下你可以扑ֈ� javadoc�Q�如果是 Windows 下的 JDK�Q�它的文件名�?javadoc.exe。��?javdoc �~�译 .java 源文件时�Q�它会读�?.java 源文件中的文档注释，�q�按照一定的规则�?Java 源程序一赯��行编译，生成文档�?/P>

　　介绍 javadoc 的编译命令之前，�q�是先了解一下文��注释的格式吧。不�q��ؓ了能够编译下面提到的若干例子�Q�这里先介绍一�?javadoc 命��o�Q?/P>

　　javadoc -d 文��存放目录 -author -version 源文件名.java

　　�q�条命��o�~�译一个名�?“源文�g�?java”的 java 源文�Ӟ��q�将生成的文��存攑֜�“文��存攄��录”指定的目录下，生成的文��中 index.html ��是文档的首��c�?author �?-version 两个选项可以省略�?/P>

�? 文��注释的格�?/B>

　　文��注释可以用于对类、属性、方法等�q�行说明。写文��注释旉��了需要��?/** .... */ 限定之外�Q�还需要注意注释内部的一些细节问题�?/P>
　　1. 文��和文档注释的格式�?/P>
　　生成的文��是 HTML 格式�Q�而这�?HTML 格式的标识符�q�不�?javadoc 加的�Q�而是我们在写注释的时候写上去的。比如，需要换行时�Q�不是敲入一个回车符�Q�而是写入
�Q�如果要分段�Q�就应该在段前写�?
�?/P>
　　因此�Q�格式化文��Q�就是在文��注释中添加相应的 HTML 标识�?/P>
　　文��注释的正文�ƈ不是直接复制到输出文�?(文档�?HTML 文�g)�Q�而是��d��每一行后�Q�删掉前导的 * 号及 * 号以前的�I�格�Q�再输入到文��的。如

/**
* This is first line.

***** This is second line.

This is third line.
*/

　　�~�译输出后的 HTML 源码则是

This is first line.

This is second line.

This is third line.

　　前导�?* 号允许连�l��用多个，其效果和使用一�?* 号一��P��但多�?* 号前不能有其它字�W�分隔，否则分隔�W�及后面�?* 号都��作为文档的内容�? 号在�q�里是作为左边界使用�Q�如上例的第一行和�W�二行；如果没有前导�?* ��P��则边界从�W�一个有效字�W�开始，而不包括前面的空��|��如上例第三行�?/P>
　　�q�有一炚w��要说明，文��注释只说明紧接其后的�c�R��属性或者方法。如下例�Q?/P>

/** comment for class */ public class Test { /** comment for a attribute */ int number; /** comment for a method */ public void myMethod() { ...... } ...... }

　　上例中的三处注释��是分别对类、属性和�Ҏ��的文档注释。它们生成的文��分别是说明紧接其后的�c�R��属性、方法的。“紧接”二字尤光��要，如果忽略了这一点，��很可能造成生成的文��错误。如

import java.lang.*; /** commnet for class */ public class Test { ...... } // 此例为正��的例子

　　�q�个文��注释��生成正��的文��。但只需要改变其中两行的位置�Q�变成下例，��׃��出错�Q?/P>

/** commnet for class */ import java.lang.*; public class Test { ...... } // 此例为错误的例子

　　�q�个例子只把上例�?import 语句和文档注释部分交换了位置�Q�结果却大不相同——生成的文档中根本就找不��C��q�注释的内容了。原因何在？

　　�?FONT color=#008000>/** commnet for class */”是�?class Test 的说明，把它攑֜�“public class Test { ...... }”之前时�Q�其后紧接着 class Test�Q�符合规则，所以生成的文��正确。但是把它和“import java.lang.*;”调换了位置后，其后紧接的就是不 class Test 了，而是一�?import 语句。由于文��注释只能说明类、属性和�Ҏ��Q�import 语句不在此列�Q�所以这个文档注释就被当作错误说明省略掉了�?/P>
　　2. 文档注释的三部分

　　�Ҏ��在文��中昄��的效果，文档注释分�ؓ三部分。先举例如下�Q�以便说明�?/P>

/** * show �Ҏ��的简�q? *
show �Ҏ��的详�l�说明第一�?lt;br> * show �Ҏ��的详�l�说明第二行 * @param b true 表示昄��Q�false 表示隐藏 * @return 没有�q�回�? */ public void show(boolean b) { frame.show(b); }

　　�W�一部分是简�q�。文档中�Q�对于属性和�Ҏ��都是先有一个列表，然后才在后面一个一个的详细的说明。列表中属性名或者方法名后面那段说明��是��q�。如下图中被�U�框框选的部分�Q?/P>

　　��q�部分写在一�D�|��档注释的最前面�Q�第一个点�?(.) 之前 (包括点号)。换句话��_��是用第一个点号分隔文��注释，之前是简�q�ͼ�之后是第二部分和�W�三部分。如上例中的 �? show �Ҏ��的简�q?”�?/P>
　　有时�Q�即使正��地以一个点号作为分隔，javadoc 仍然会出错，把点号后面的部分也做��Z��W�一部分。�ؓ了解册��个问题，我们可以使用一�?
标志��第二分部分开��Z��一�D�，如上例的�?
show �Ҏ��的详�l�说明第一�?....”。除此之外，我们也可以��?
来分隔�?/P>
　　�W�二部分是详�l�说明部分。该部分对属性或者方法进行详�l�的说明�Q�在格式上没有什么特�D�的要求�Q�可以包含若�q�个点号。它在文��中的位�|�如下图所�C�：

　　�q�部分文��在上例中相应的代码是：

　　* show �Ҏ��的简�q?
　　 *
show �Ҏ��的详�l�说明第一�?lt;br>
　　 * show �Ҏ��的详�l�说明第二行

　　发现什么了�Q�对了，��q�C��在其中。这一点要��C��了，不要画蛇添��——在详细说明部分中再写一�ơ简�q�哦�Q?/P>
　　�W�三部分是特�D�说明部分。这部分包括版本说明、参数说明、返回��D��明等。它在文��中的位�|�：

　　�W�三部分在上例中相应的代码是

　　* @param b true 表示昄��Q�false 表示隐藏
　　 * @return 没有�q�回�?/FONT>

　　除了 @param �?@return 之外�Q�还有其它的一些特�D�标讎ͼ�分别用于对类、属性和�Ҏ��的说明……不要推我，我马上就说�?/P>

�? 使用 javadoc 标记

　　javadoc 标记是插入文��注释中的特�D�标讎ͼ�它们用于标识代码中的�Ҏ��引用。javadoc 标记由“@”及其后所跟的标记�c�d��和专用注释引用组成。记住了�Q�三个部分——@、标记类型、专用注释引用。不�q�我宁愿把它分成两部分：@ 和标记类型、专用注释引用。虽�?@ �?标记�c�d��之间有时可以用空格符分隔�Q�但是我宁愿始终��它们紧挨着写，以减��出错机会�?/P>
　　javadoc 标记有如下一些：

标记用于作用

@author 对类的说�?/TD> 标明开发该�c�L��块的作�?/TD>

@version 对类的说�?/TD> 标明该类模块的版�?/TD>

@see 对类、属性、方法的说明参考�{向，也就是相关主�?/TD>

@param �Ҏ��法的说明 �Ҏ��法中某参数的说明

@return �Ҏ��法的说明 �Ҏ��法返回值的说明

@exception �Ҏ��法的说明 �Ҏ��法可能抛出的异常�q�行说明

　　下面详细说明各标记�?/P>
　　1. @see 的��?/P>
　　@see 的句法有三种�Q?

　　@see �c�d��
　　 @see #�Ҏ��名或属性名
　　 @see �c�d��#�Ҏ��名或属性名

　　�c�d��Q�可以根据需要只写出�c�d�� (�?String) 或者写出类全名 (�?java.lang.String)。那么什么时候只需要写出类名，什么时候需要写出类全名呢？

　　如果 java 源文件中�?import 语句包含了的�c�，可以只写出类名，如果没有包含�Q�则需要写出类全名。java.lang 也已�l�默认被包含了。这�?javac �~�译 java 源文件时的规定一��P��所以可以简单的�?javac �~�译来判断，源程序中 javac 能找到的�c�，javadoc 也一定能扑ֈ��Q�javac 找不到的�c�，javadoc 也找不到�Q�这��需要��用类全名了�?/P>
　　�Ҏ��名或者属性名�Q�如果是属性名�Q�则只需要写出属性名卛_��Q�如果是�Ҏ��名，则需要写出方法名以及参数�c�d��Q�没有参数的�Ҏ��Q�需要写��Z��Ҏ��受��如

成员�c�d�� 成员名称及参�?/B> @see 句法

属�?/TD> number @see number

属�?/TD> count @see count

�Ҏ�� count() @see count()

�Ҏ�� show(boolean b) @see show(boolean)

�Ҏ�� main(String[] args) @see main(String[])

　　有时也可以偷懒：假如上例中，没有 count �q�一属性，那么参考方�?count() ��可以简写成 @see count。不�q�，��Z��安全赯��Q�还是写�?@see count() 比较好�?/P>
　　@see 的第二个句法和第三个句法都是转向�Ҏ��或者属性的参考，它们有什么区别呢�Q?/P>
　　�W�二个句法中没有指出�c�d��Q�则默认为当前类。所以它定义的参考，都�{向本�c�M��的属性或者方法。而第三个句法中指��Z��c�d��Q�则�q�可以�{向其它类的属性或者方法�?/P>
　　关于 @see 标记�Q�我们�D个例说明。由�?@see 在对�c�说明、对属性说明、对�Ҏ��说明时用法都一��P��所以这里只以对�c�说明�ؓ例�?/P>

/** * @see String * @see java.lang.StringBuffer * @see #str * @see #str() * @see #main(String[]) * @see Object#toString() */ public class TestJavaDoc { }

　　生成的文��的相关部分如下图：

　　String �?StringBuffer 都是�?java.lang 包中�Q�由于这个包是默认导入了的，所以这两个�c�d��以直接写�c�d��Q�也可以写类全名。str、str() 为同名属性和�Ҏ��Q�所以方法名需要用 () 区分。main 是带参数的方法，所以在 () 中指明了参数�c�d��。toString() 虽然在本�c�M��也有 (�?Object �l�承�?�Q�但我们是想参�?Object �cȝ�� toString() �Ҏ��Q�所以��用了 Object#toString()�?/P>
　　奇怪的是，��Z��么其中只�?str、str() �?main(String[]) 变成了链接呢�Q�那是因为编译时没有�?java.lang 包或�?Stirng、StringBuffer、Object 三个�cȝ��源文件一起加入编译，所以，生成的文��没有关于那三个�cȝ��信息�Q�也��׃��可以建立链接了。后面讲�?javadoc �~�译命��o的时候还会详�l�说明�?/P>
　　上例中如果去把类中的 str 属性去掉，那么生成的文��又会有什么变化呢�Q�你会发玎ͼ�原来�?str, str()�Q�而现在变成了 str(), str()�Q�因�?str 属性已�l�没有了�Q�所�?str 也表�C�方�?str()�?/P>
　　2. 使用 @author、@version 说明�c?/P>
　　�q�两个标记分别用于指明类的作者和版本。缺省情况下 javadoc ��其忽略�Q�但命��o行开�?-author �?-version 可以修改�q�个功能�Q��其包含的信息被输出。这两个标记的句法如下：

　　@author 作者名
　　 @version 版本�?/FONT>

　　其中�Q�@author 可以多次使用�Q�以指明多个作者，生成的文档中每个作者之间��用逗号 (,) 隔开。@version 也可以��用多�ơ，只有�W�一�ơ有效，生成的文档中只会昄��W�一�ơ��?@version 指明的版本号。如下例

/** * @author Fancy * @author Bird * @version Version 1.00 * @version Version 2.00 */ public class TestJavaDoc { }

　　生成文档的相关部分如图：

　　从生成文档的囄��中可以看出，两个 @author 语句都被�~�译�Q�在文��中生成了作者列表。而两�?@version 语句中只有第一句被�~�译了，只生成了一个版本号�?/P>
　　从图上看�Q�作者列表是以逗号分隔的，如果我想分行昄��怎么办？另外�Q�如果我��x��C�Z��个以上的版本号又该怎么办？

　　——我们可以将上述两条 @author 语句合�ؓ一句，把两�?@version 语句也合��Z��句：

　　@author Fancy
Bird
　　 @version Version 1.00
Version 2.00

　　�l�果如图�Q?/P>

　　我们�q�样做即辑ֈ�了目的，又没有破坏规则。@author 之后的作者名�?@version 之后的版本号都可以是用户自己定义的�Q�?HTML 格式�Q�所以我们可以��?
标记��其分行昄��。同�Ӟ��在一�?@version 中指明两个用
分隔的版本号�Q�也没有破坏只显�C�第一�?@version 内容的规则�?/P>
　　3. 使用 @param、@return �?@exception 说明�Ҏ��

　　�q�三个标记都是只用于�Ҏ��的。@param 描述�Ҏ��的参敎ͼ�@return 描述�Ҏ��的返回��|��@exception 描述�Ҏ��可能抛出的异常。它们的句法如下�Q?/P>
　　@param 参数�?参数说明
　　 @return �q�回��D��?BR>　　 @exception 异常�c�d�� 说明

　　每一�?@param 只能描述�Ҏ��的一个参敎ͼ�所以，如果�Ҏ��需要多个参敎ͼ��需要多�ơ��?@param 来描�q��?/P>
　　一个方法中只能用一�?@return�Q�如果文��说明中列了多个 @return�Q�则 javadoc �~�译时会发出警告�Q�且只有�W�一�?@return 在生成的文档中有效�?/P>
　　�Ҏ��可能抛出的异常应当用 @exception 描述。由于一个方法可能抛出多个异常，所以可以有多个 @exception。每�?@exception 后面应有��q�的异常�c�d��Q�说明中应指出抛出异常的原因。需要注意的是，异常�c�d��应该�Ҏ��源文件的 import 语句��定是写出类名还是类全名�?　　�C�Z��如下�Q?/P>

public class TestJavaDoc { /** * @param n a switch * @param b excrescent parameter * @return true or false * @return excrescent return * @exception java.lang.Exception throw when switch is 1 * @exception NullPointerException throw when parameter n is null */ public boolean fun(Integer n) throws Exception { switch (n.intValue()) { case 0: break; case 1: throw new Exception("Test Only"); default: return false; } return true; } }

　　使用 javadoc �~�译生成的文档相关部分如下图�Q?/P>

　　可以看到�Q�上例中 @param b excrescent parameter 一句是多余的，因�ؓ参数只是一�?n�Q��ƈ没有一�?b?�Q?�?javadoc �~�译时�ƈ没有��查。因此，写文��注释时一定要正确匚w��参数表与�Ҏ��中正式参数表的项目。如果方法参数表中的参数�?a�Q�文��中却给出对参数 x 的解释，或者再多出一个参�?i�Q�就会让人摸不着头脑了。@exceptin 也是一栗��?/P>
　　上例�E�序中�ƈ没有抛出一�?NullPointerException�Q�但是文��注释中��Z��么要写上�q�么一句呢�Q�难道又是�ؓ了演�C�？�q�不是�ؓ了演�C�描�q�多余的异常也能通过�~�译�Q�而是��Z��说明写异常说明时应考运行时 (RunTime) 异常的可能性。上例程序中�Q�如果参�?n 是给的一个空�?(null)�Q�那么程序会在运行的时候抛��Z��?NullPointerException�Q�因此，在文��注释中��d��了对 NullPointerException 的说明�?/P>
　　上例中的 @return 语句有两个，但是�Ҏ��规则�Q�同一个方法中�Q�只有第一�?@return 有效�Q�其余的会被 javadoc 忽略。所以生成的文��中没有出现第二个 @return 的描�q��?/P>
　　讲到�q�里�Q�该怎么写文档注释你应该已经清楚了，下面��开始讲�?javadoc 的常用命令�?/P>

�? javadoc 命��o

　　�q�行 javadoc -help 可以看到 javadoc 的用法，�q�里列�D常用参数如下�Q?/P>
用法�Q?BR>　　 javadoc [options] [packagenames] [sourcefiles]

选项�Q?/P>

-public 仅显�C?public �c�d��成员

-protected 昄�� protected/public �c�d��成员 (�~�省)

-package 昄�� package/protected/public �c�d��成员

-private 昄��所有类和成�?/TD>

-d 输出文�g的目标目�?/TD>

-version 包含 @version �D?/TD>

-author 包含 @author �D?/TD>

-splitindex ��烦引分为每个字母对应一个文�?/TD>

-windowtitle 文档的浏览器�H�口标题

　　javadoc �~�译文档时可以给定包列表�Q�也可以�l�出源程序文件列表。例如在 CLASSPATH 下有两个包若�q�类如下�Q?/P>
　　fancy.Editor
　　 fancy.Test
　　 fancy.editor.ECommand
　　 fancy.editor.EDocument
　　 fancy.editor.EView

　　�q�里有两个包 (fancy �?fancy.editor) �?5 个类。那么编译时 (Windows 环境) 可以使用如下 javadoc 命��o�Q?/P>
　　javadoc fancy\Test.java fancy\Editor.java fancy\editor\ECommand.java fancy\editor\EDocument.java fancy\editor\EView.java

　　�q�是�l�出 java 源文件作为编译参数的�Ҏ��Q�注意命令中指出的是文�g路径�Q�应该根据实际情冉|��变。也可以是给出包名作为编译参敎ͼ�如：

　　javadoc fancy fancy.editor

　　用浏览器打开生成文��?index.html 文�g卛_��发现两种方式�~�译�l�果的不同，如下图：

　　用第二条命��o生成的文��被框架分成了三部分�Q�包列表、类列表和类说明。在包列表中选择了某个包之后�Q�类列表中就会列��包中的所有类�Q�在�c�d��表中选择了某个类之后�Q�类说明部分��׃��昄��cȝ��详细文��。而用�W�一条命令生成的文��只有两部分，�c�d��表和�c�说明，没有包列表。这��是两种方式生成文��的最大区别了�?/P>
　　下面再来�l�说选项�?/P>
　　-public�?protected�?package�?private 四个选项�Q�只需要�Q选其一卛_��。它们指定的昄��c�L��员的�E�度。它们显�C�的成员多少是一个包含的关系�Q�如下表�Q?/P>

-private (昄��所有类和成�?

-package (昄�� package/protected/public �c�d��成员)

-protected (昄�� protected/public �c�d��成员)

-public (仅显�C?public �c�d��成员)

　　-d 选项允许你定义输出目录。如果不�?-d 定义输出目录�Q�生成的文档文�g会放在当前目录下�?d 选项的用法是

　　-d 目录�?/FONT>

　　目录名�ؓ必填��，也就是说�Q�如果你使用�?-d 参数�Q�就一定要为它指定一个目录。这个目录必��d��l�存在了�Q�如果还不存在，请在�q�行 javadoc 之前创徏该目录�?/P>
　　-version �?-author 用于控制生成文��时是否生�?@version �?@author 指定的内宏V��不加这两个参数的情况下�Q�生成的文��中不包含版本和作者信息�?/P>
　　-splitindex 选项��烦引分为每个字母对应一个文件。默认情况下�Q�烦引文件只有一个，且该文�g中包含所有烦引内宏V��当然生成文档内容不多的时候，�q�样做非常合适，但是�Q�如果文��内定w��常多的时候，�q�个索引文�g��包含非常多的内容，昑־��q�于庞大。��?-splitindex 会把索引文�g按各索引��的�W�一个字母进行分�c�，每个字母对应一个文件。这��P��减��M��一个烦引文件的负担�?/P>
　　-windowtitle 选项为文档指定一个标题，该标题会昄��在窗口的标题栏上。如果不指定该标题，而默认的文��标题为“生成的文��Q�无标题�Q�”。该选项的用法是�Q?/P>
　　-windowtitle 标题

　　标题是一串没有包含空格的文本�Q�因为空格符是用于分隔各参数的，所以不能包含空根{��同 -d �c�M��Q�如果指定了 -windowtitle 选项�Q�则必须指定标题文本�?/P>
　　到此为止�Q�Java 文档�?javadoc ��׃��l�完了。javadoc 真的能让我们�?Java 注释上做文章——生成开发文��?/P>

黑石 2005-12-21 12:15 发表评论

java中静态方法和非静态方法覆盖的区别

黑石 — Wed, 21 Dec 2005 03:16:00 GMT

　首先我们提供两个�c�，基类�?/FONT>Parent�Q�派生类�?/FONT>Child。在Parent中我们提供两个方法，一个是静态方�?/FONT>staticMethod(),一个是非静态方�?/FONT>nonStaticMethod()。在Child

�c�M��我们覆盖着两个�Ҏ��?

class Parent{

public void nonStaticMethod() {

System.out.println("Parent's Non-Static Method is Called");

}

public static void staticMethod() {

System.out.println("parent's static method is called");

}

class Child extends Parent{

public void nonStaticMethod() {

System.out.println("child's non-static method is called");

}

public static void staticMethod() {

System.out.println("child's static method is called");

}

�?/FONT>Test�c�M��我们分别使用Parent p1 = new Parent(),Parent p2 = new Child(),Child c = new Child() 得到三个实例�Q��ƈ分别调用静态方法和非静态方法，我们来看�E�序的运行结�?

�?/FONT>Test�c�M��我们分别使用Parent p1 = new Parent(),Parent p2 = new Child(),Child c = new Child()得到三个实例�Q��ƈ分别调用静态方法和非静态方法，我们来看�E�序的运行结�?

public class Test{

public static void main(String args[]) {

Parent p1 = new Parent();

Parent p2 = new Child();

Child c = new Child();

System.out.print("Parent.static: ");

Parent.staticMethod();

System.out.print("p1.static: ");

p1.staticMethod();

System.out.print("p2.static: ");

p2.staticMethod();

System.out.print("p1.nonStatic: ");

p1.nonStaticMethod();

System.out.print("p2.nonStatic: ");

p2.nonStaticMethod();

System.out.print("Child.static: ");

Child.staticMethod();

System.out.print("c.static: ");

c.staticMethod();

System.out.print("c.nonStatic: ");

c.nonStaticMethod();

}

�E�序的运行结果�ؓ�Q?

Parent.static: parent's static method is called

p1.static: parent's static method is called

p2.static: parent's static method is called

p1.nonStatic: Parent's Non-Static Method is Calle

p2.nonStatic: child's non-static method is called

Child.static: child's static method is called

c.static: child's static method is called

c.nonStatic: child's non-static method is called

值得注意的是p2实际上是一个Child的类型的引用�Q�然而在调用静态方法的时候，它执行的却是父类的静态方法，而不是Child的静态方法，而调�?p2的非静态方法的时候执行的是Child 的非静态方法，��Z��么呢�Q?FONT color=#ff0000>原因是静态方法是在编译的时候把静态方法和�cȝ��引用�c�d��q�行匚w��Q�而不是在�q�行的时候和�c�d��用进行匹配。因此我们得出结论：当我们在子类中创建的静态方法，它�ƈ不会覆盖父类中相同名字的静态方法�?

黑石 2005-12-21 11:16 发表评论

理解构造器

黑石 — Wed, 21 Dec 2005 02:51:00 GMT

要学习Java,你必��ȝ��解构造器。因为构造器可以提供许多�Ҏ��的方法，�q�个对于初学者经常�؜淆。但是，构造器和方法又有很多重要的区别�?BR>
我们说构造器是一�U�方法，��p��讲澳大利亚的鸭嘴兽是一�U�哺育动物。（按：老外喜欢打比喻，我也��q��着��译�Q�。要理解鸭嘴兽，那么先必��ȝ��解它和其他哺育动物的区别。同样地�Q�要理解构造器�Q�那么就要了解构造器和方法的区别。所有学习java的�h�Q�尤其是寚w��些要认证考试的，理解构造器是非帔R��要的。下面将��单介�l�一�?�Q�最后用一个表作了些简单的�ȝ��?

一�?FONT color=#0000ff>功能和作用的不同
构造器是�ؓ了创��Z��个类的实例。这个过�E�也可以在创��Z��个对象的时候用刎ͼ�Platypus p1 = new Platypus();

相反�Q�方法的作用是�ؓ了执行java代码�?

二、修饰符�Q�返回值和命名的不�?/SPAN>
构造器和方法在下面三个斚w��的区别：修饰�W�，�q�回��|��命名。和�Ҏ��一��P��构造器可以有�Q何访问的修饰�Q?public, protected, private或者没有修饎ͼ�通常被package �?friendly调用�Q? 不同于方法的是，构造器不能有以下非讉K��性质的修饎ͼ� abstract, final, native, static, 或�?synchronized�?

�q�回�c�d��也是非常重要的。方法能�q�回��M��c�d��的值或者无�q�回��|��void�Q�，构造器没有�q�回��|��也不需要void�?

最后，谈谈两者的命名。构造器使用和类相同的名字，而方法则不同。按照习惯，�Ҏ��通常用小写字母开始，而构造器通常用大写字母开始。构造器通常是一个名词，因�ؓ它和�c�d��相同�Q�而方法通常更接�q�动词，因�ؓ它说明一个操作�?

三�?this"的用�?/SPAN>
构造器和方法��用关键字this有很大的区别。方法引用this指向正在执行�Ҏ��的类的实例。静态方法不能��用this关键字，因�ؓ静态方法不属于�cȝ��实例�Q�所以this也就没有什么东西去指向。构造器的this指向同一个类中，不同参数列表的另外一个构造器�Q�我们看看下面的代码�Q?

public class Platypus {

String name;

Platypus(String input) {
name = input;
}

Platypus() {
this("John/Mary Doe");
}

  public static void main(String args[]) {
    Platypus p1 = new Platypus("digger");
   Platypus p2 = new Platypus();
  }
}

在上面的代码中，�?个不同参数列表的构造器。第一个构造器�Q�给�cȝ��成员name赋��|��W�二个构造器�Q�调用第一个构造器�Q�给成员变量name一个初始�?"John/Mary Doe".

在构造器中，如果要��用关键字this,那么�Q�必��L��在第一行，如果不这��P��导致一个编译错误�?

四�?super"的用�?
构造器和方法，都用关键字super指向��类�Q�但是用的方法不一栗��方法用�q�个关键字去执行被重载的��类中的�Ҏ��。看下面的例子：

class Mammal {
   void getBirthInfo() {
      System.out.println("born alive.");
   }
}

class Platypus extends Mammal {
   void getBirthInfo() {
     System.out.println("hatch from eggs");
     System.out.print("a mammal normally is ");
     super.getBirthInfo();
   }
}

在上面的例子中，使用super.getBirthInfo()去调用超�c�Mammal中被重蝲的方法�?

构造器使用super去调用超�c�M��的构造器。而且�q�行代码必须攑֜��W�一行，否则�~�译��出错。看下面的例子：

public class SuperClassDemo {
SuperClassDemo() {}
}

class Child extends SuperClassDemo {
  Child() {
      super();
  }
}

在上面这个没有什么实际意义的例子中，构造器 Child()包含�?super,它的作用��是��超�c�M��的构造器SuperClassDemo实例化，�q�加�?Child�c�M��?

五、编译器自动加入代码
�~�译器自动加入代码到构造器�Q�对于这个，java�E�序员新手可能比较�؜淆。当我们写一个没有构造器的类�Q�编译的时候，�~�译器会自动加上一个不带参数的构造器�Q�例如：public class Example {}
�~�译后将如下代码�Q?

public class Example {
Example() {}
}

在构造器的第一行，没有使用super�Q�那么编译器也会自动加上�Q�例如：

public class TestConstructors {
TestConstructors() {}
}

�~�译器会加上代码�Q�如下：

public class TestConstructors {
  TestConstructors() {
    super();
  }
}

仔细想一下，��q��道下面的代码

public class Example {}

�l�过会被�~�译器加代码形如�Q?

public class Example {
   Example() {
     super();
   }
}

六、��?/SPAN>
构造器是不能被�l�承的。子�c�d��以��承超�cȝ��M��Ҏ��。看看下面的代码�Q?

public class Example {
  public void sayHi {
    system.out.println("Hi");
  }

Example() {}
}

public class SubClass extends Example {
}

�c?SubClass 自动�l�承了父�c�M��的sayHi�Ҏ��Q�但是，父类中的构造器 Example()却不能被�l�承�?

�ȝ��

主题	构造器	�Ҏ��
功能	建立一个类的实�?	java功能语句
修饰	不能用bstract, final, native, static, or synchronized	�?/TD>
�q�回�c�d��	没有�q�回��\|��没有void	有返回��\|��或者void
命名	和类名相同；通常为名词，大写开�?/TD>	通常代表一个动词的意思，��写开�?/TD>
this	指向同一个类中另外一个构造器�Q�在�W�一�?	指向当前�cȝ��一个实例，不能用于静态方�?/TD>
super	调用父类的构造器�Q�在�W�一�?/TD>	调用父类中一个重载的�Ҏ��
�l�承	构造器不能被��?	�Ҏ��可以被��?
�~�译器自动加入一个缺省的构造器	自动加入�Q�如果没有）	不支�?
�~�译器自动加入一个缺省的调用到超�cȝ��构造器	自动加入�Q�指super(),如果没有�Q?/TD>	不支�?

黑石 2005-12-21 10:51 发表评论

黑石 — Wed, 21 Dec 2005 01:12:00 GMT

abstract class base
{
    public int age=getNumber(100);
    static
    {
        System.out.println("base static block");
    }
    {
        System.out.println("base nonstatic block");
    }
    static int sage=getNumber(50);
    base()
    {
        System.out.println(age);
        System.out.println("base start");
        draw();//会调用子�c�覆盖后的方�?
        System.out.println("base end");
        
    }
    static int getNumber(int base)
    {
        System.out.println("base.getNumber int"+base);
        return base;
    }
    public  void draw()
    {
        System.out.println("base.draw");
    }
}
public class initializeOrder extends base{
    public int age=getNumber(1001);
    private int _radius=getNumber(10);
    static int sage=getNumber(250);
    static
    {
        System.out.println("subclass static block");
    }
    {
        System.out.println("subclass nonstatic block");
    }
    initializeOrder(int radius)
    {
        _radius=radius;
        System.out.println(age);
        System.out.println("initializeOrder initialized");
    }
    public void draw()
    {
        System.out.println("initializeOrder.draw "+_radius);
    }
    /** *//**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new initializeOrder(1000);
    }
}

 �q�行�l�果�Q?BR>
C:\java>java    initializeOrder
base static block
base.getNumber int50
base.getNumber int250
subclass static block
base.getNumber int100
base nonstatic block
100
base start
initializeOrder.draw 0
base end
base.getNumber int1001
base.getNumber int10
subclass nonstatic block
1001
initializeOrder initialized

C:\java>

�ȝ��Q?BR>1、类只有在��用New调用创徏的时候才会被JAVA�c�装载器装入
2、JAVA�c�首�ơ装入时�Q�会寚w��态成员变量或�Ҏ��q�行一�ơ初始化,但方法不被调用是不会执行的，静态成员变量和静态初始化块��别相同，非静态成员变量和非静态初始化块��别相同�?BR>先初始化父类的静态代�?-->初始化子�cȝ��静态代�?->
初始化父�cȝ��非静态代�?-->初始化父�c�L��造函�?-->
初始化子�c�非静态代�?-->初始化子�c�L��造函�?BR>3、创建类实例�Ӟ��首先按照父子�l�承关系�q�行初始�?BR>4、类实例创徏时候，首先初始化块部分先执行，然后是构造方法；然后�?BR>本类�l�承的子�cȝ��初始化块执行�Q�最后是子类的构造方�?BR>5、类消除时候，首先消除子类部分�Q�再消除父类部分
��试:

package com.javabase;

/**
*

Title: �q�x��例子练�?lt;/p>
*
*

Description: �q�x��例子练�?lt;/p>
*
*

*
*
Company: 北京开元东方科技有限公司

*
* @author 樊徏�?BR> * @version 1.0
* ��试java�c�d��载初始化��序
*/
abstract class base
{
    public int age=getNumber(100);
    static
    {
        System.out.println("base static block");
    }
    {
        System.out.println("base nonstatic block");
    }
    static int sage=getNumber(50);
    base()
    {
        System.out.println(age);
        System.out.println("base start");
        draw();//会调用子�c�覆盖后的方法，哪批怕写在游��d��中也会执行子�c�覆盖后的方�?BR>        System.out.println("base end");

    }
    static int getNumber(int base)
    {
        System.out.println("base.getNumber int"+base);
        return base;
    }
    public void draw()
    {
        System.out.println("base.draw");
    }
}

public class JavaBase extends base{
    public int age=getNumber(1001);
    private int _radius=getNumber(10);
    static int sage=getNumber(250);
    static
    {
        System.out.println("subclass static block");
    }
    {
        System.out.println("subclass nonstatic block");
    }
    JavaBase(int radius)
    {
        _radius=radius;
        System.out.println(age);
        System.out.println("initializeOrder initialized");
    }
    public void draw()
    {
        System.out.println("initializeOrder.draw "+_radius);
    }
    /** *//**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("-------------�c�d��始化开�?------------");
        new JavaBase(1000);
        System.out.println("-------------�c�d��始化�l�束-------------");
    }
}

执行�l�果:

base static block

base.getNumber int50

base.getNumber int250

subclass static block

-------------�c�d��始化开�?------------

base.getNumber int100

base nonstatic block

initializeOrder.draw 0

100

base start

base end

base.getNumber int1001

base.getNumber int10

subclass nonstatic block

1001

initializeOrder initialized

-------------�c�d��始化�l�束-------------
更正:static静态成员变量和静态初始化是在new对象之前�q�行�?

后待��d��更正***************************************************************

Static详解:

一、static

　　请先看下面这�D늨�序：

public class Hello{
    public static void main(String[] args){ //(1)
      System.out.println("Hello,world!");   //(2)
    }
}

　　看过�q�段�E�序�Q�对于大多数学过Java 的从来说�Q�都不陌生。即使没有学�q�Java�Q�而学�q�其它的高��语言�Q�例如C�Q�那你也应该能看懂这�D�代码的意思。它只是��单的输出“Hello,world”，一点别的用处都没有�Q�然而，它却展示了static关键字的主要用法�?/P>

　　�?处，我们定义了一个静态的�Ҏ��名�ؓmain�Q�这��意味着告诉Java�~�译器，我这个方法不需要创��Z��个此�cȝ��对象卛_��使用。你�q�记得你是怎么�q�行�q�个�E�序吗？一般，我们都是在命令行下，打入如下的命令：

javac Hello.java
java Hello
Hello,world!

　　�q�就是你�q�行的过�E�，�W�一行用来编译Hello.java�q�个文�g�Q�执行完后，如果你查看当前，会发现多了一个Hello.class文�g�Q�那��是�W�一行��生的Java二进制字节码。第二行��是执行一个Java�E�序的最普遍做法。执行结果如你所料。在2中，你可能会惻I��Z��么要�q�样才能输出。好�Q�我们来分解一下这条语句。（如果没有安装Java文��Q�请到Sun的官方网站浏览J2SE API�Q�首先，System是位于java.lang包中的一个核心类�Q�如果你查看它的定义�Q�你会发现有�q�样一行：public static final PrintStream out;接着再进一步，点击PrintStream�q�个��链接，在METHOD��面�Q�你会看到大量定义的�Ҏ��Q�查找println�Q�会有这样一行：

public void println(String x)�?/P>

　　好了�Q�现在你应该明白��Z��么我们要那样调用了，out是System的一个静态变量，所以可以直接��用，而out所属的�c�L��一个println�Ҏ��?/P>

静态方�?/STRONG>

　　通常�Q�在一个类中定义一个方法�ؓstatic�Q�那��是��_��用类名而无需本类的对象即可调用此�Ҏ��。如下所�C�：

class Simple{
   static void go(){
     System.out.println("Go...");
   }
}
public class Cal{
public static void main(String[] args){
    Simple.go();
}
}

　　调用一个静态方法就是“类�?�Ҏ��名�?静态方法的使用很简单如上所�C�。一般来��_��静态方法常��ؓ应用�E�序中的其它�c�L��供一些实用工��h��用，在Java的类库中大量的静态方法正是出于此目的而定义的�?/P>
静态变�?/STRONG>

　　静态变量与静态方法类伹{��所有此�c�d��例共享此静态变量，也就是说在类装蝲�Ӟ��只分配一块存储空��_��所有此�cȝ��对象都可以操控此块存储空��_��当然对于final则另当别��Z��。看下面�q�段代码�Q?/P>
class Value{
static int c=0;
static void inc(){
    c++;
}
}
class Count{
public static void prt(String s){
    System.out.println(s);
}
public static void main(String[] args){
    Value v1,v2;
    v1=new Value();
    v2=new Value();
    prt("v1.c="+v1.c+" v2.c="+v2.c);
    v1.inc();
    prt("v1.c="+v1.c+" v2.c="+v2.c);
}
}

　　�l�果如下�Q?/P>
v1.c=0 v2.c=0
v1.c=1 v2.c=1

由此可以证明它们�׃�n一块存储区。static变量有点�c�M��于C中的全局变量的概��c��值得探讨的是静态变量的初始化问题。我们修改上面的�E�序�Q?/P>
class Value{
static int c=0;
Value(){
    c=15;
}
Value(int i){
    c=i;
}
static void inc(){
    c++;
}
}
class Count{
public static void prt(String s){
    System.out.println(s);
}
    Value v=new Value(10);
    static Value v1,v2;
    static{
      prt("v1.c="+v1.c+" v2.c="+v2.c);
      v1=new Value(27);
      prt("v1.c="+v1.c+" v2.c="+v2.c);
      v2=new Value(15);
      prt("v1.c="+v1.c+" v2.c="+v2.c);
    }

public static void main(String[] args){
    Count ct=new Count();
    prt("ct.c="+ct.v.c);
    prt("v1.c="+v1.c+" v2.c="+v2.c);
    v1.inc();
    prt("v1.c="+v1.c+" v2.c="+v2.c);
    prt("ct.c="+ct.v.c);
}
}

�q�行�l�果如下�Q?/P>
v1.c=0 v2.c=0
v1.c=27 v2.c=27
v1.c=15 v2.c=15
ct.c=10
v1.c=10 v2.c=10
v1.c=11 v2.c=11
ct.c=11

　　�q�个�E�序展示了静态初始化的各�U�特性。如果你初次接触Java�Q�结果可能��o你吃惊。可能会对static后加大括��h��到困惑。首先要告诉你的是，static定义的变量会优先于�Q何其它非static变量�Q�不论其出现的顺序如何。正如在�E�序中所表现的，虽然v出现在v1和v2的前面，但是�l�果却是v1和v2的初始化在v的前面。在static{后面跟着一�D�代码，�q�是用来�q�行昑ּ�的静态变量初始化�Q�这�D�代码只会初始化一�ơ，且在�c�被�W�一�ơ装载时。如果你能读懂�ƈ理解�q�段代码�Q�会帮助你对static关键字的认识。在涉及到��承的时候，会先初始化父�cȝ��static变量�Q�然后是子类的，依次�c�L��?/P>
　　通常一个普通类不允许声明�ؓ静态的�Q�只有一个内部类才可以。这时这个声明�ؓ静态的内部�c�d��以直接作��Z��个普通类来��用，而不需实例一个外部类。如下代码所�C�：

public class StaticCls{
public static void main(String[] args){
    OuterCls.InnerCls oi=new OuterCls.InnerCls();
}
}
class OuterCls{
public static class InnerCls{
    InnerCls(){
      System.out.println("InnerCls");
    }
   }
}

　　输出�l�果会如你所料：

InnerCls

黑石 2005-12-21 09:12 发表评论

Junit概述

黑石 — Tue, 20 Dec 2005 10:02:00 GMT
1、概�q?BR>　　Junit��试是程序员��试�Q�即所谓白盒测试，因�ؓ�E�序员知道被��试的��Y件如何（How�Q�完成功能和完成什么样�Q�What�Q�的功能�?BR>　　Junit本质上是一套框�Ӟ��卛_��发者制定了一套条条框框，遵��@�q�此条条框框要求�~�写��试代码�Q�如�l�承某个�c�，实现某个接口�Q�就可以用Junit�q�行自动��试了�?BR>　　�׃��Junit相对独立于所�~�写的代码，可以��试代码的编写可以先于实��C��码的�~�写�Q�XP 中推崇的 test first design的实现有了现成的手段�Q�用Junit写测试代码，写实��C��码，�q�行��试�Q�测试失败，修改实现代码�Q�再�q�行��试�Q�直到测试成功。以后对代码的修改和优化�Q�运行测试成功，则修�Ҏ��功�?BR>　　Java 下的 team 开发，采用 cvs(版本控制) + ant(��目��理) + junit(集成��试) 的模式时�Q�通过对ant的配�|�，可以很简单地实现��试自动化�?BR>
　　对不同性质的被��对象，如Class�Q�Jsp�Q�Servlet�Q�Ejb�{�，Junit有不同的使用技巧，以后慢慢地分别讲叙。以下以Class��试��Z��讲解�Q�除非特�D�说明�?BR>
2、下载安�?BR>

去Junit主页下蝲最新版�?.8.1�E�序包junit-3.8.1.zip

用winzip或unzip��junit-3.8.1.zip解压�~�到某一目录名�ؓ$JUNITHOME

��junit.jar�?JUNITHOME/junit加入到CLASSPATH中，加入后者只因�ؓ��试例程在那个目录下�?BR>
注意不要��junit.jar攑֜�jdk的extension目录�?BR>
�q�行命��o,�l�果如下图�?BR>java junit.swingui.TestRunner junit.samples.AllTests

3、Junit架构
　　下面以Money�q�个�c�Mؓ例进行说明�?BR>
public class Money {
private int fAmount;//余额
private String fCurrency;//货币�c�d��

public Money(int amount, String currency) {
      fAmount= amount;
      fCurrency= currency;
}

public int amount() {
      return fAmount;
}

public String currency() {
      return fCurrency;
}

public Money add(Money m) {//加钱
      return new Money(amount()+m.amount(), currency());
}

public boolean equals(Object anObject) {//判断钱数是否相等
      if (anObject instanceof Money) {
         Money aMoney= (Money)anObject;
         return aMoney.currency().equals(currency())
            && amount() == aMoney.amount();
      }
      return false;
}
}

　　Junit本��n是围�l�着两个设计模式来设计的�Q�命令模式和集成模式.

命��o模式
　　利用TestCase定义一个子�c�，在这个子�c�M��生成一个被��试的对象，�~�写代码��某个方法被调用后对象的状态与预期的状态是否一��_��q�而断�a��E�序代码有没有bug�?BR>　　当这个子�c�要��试不只一个方法的实现代码�Ӟ��可以先徏立测试基��Q�让�q�些��试在同一个基��上运行，一斚w��可以减少每个��试的初始化�Q�而且可以��试�q�些不同�Ҏ��之间的联�p�R�?BR>　　例如�Q�我们要��试Money的Add�Ҏ��Q�可以如�?
public class MoneyTest extends TestCase { //TestCase的子�c?BR> public void testAdd() { //把测试代码放在testAdd�?BR>       Money m12CHF= new Money(12, "CHF");  //本行和下一行进行一些初始化
      Money m14CHF= new Money(14, "CHF");
      Money expected= new Money(26, "CHF");//预期的结�?BR>       Money result= m12CHF.add(m14CHF); //�q�行被测试的�Ҏ��
      Assert.assertTrue(expected.equals(result));    //判断�q�行�l�果是否与预期的相同
}
}

　　如果��试一下equals�Ҏ��Q�用�c�M��的代码，如下�Q?BR>public class MoneyTest extends TestCase { //TestCase的子�c?BR> public void testEquals() { //把测试代码放在testEquals�?BR>       Money m12CHF= new Money(12, "CHF"); //本行和下一行进行一些初始化
      Money m14CHF= new Money(14, "CHF");

      Assert.assertTrue(!m12CHF.equals(null));//�q�行不同情况的测�?BR>       Assert.assertEquals(m12CHF, m12CHF);
      Assert.assertEquals(m12CHF, new Money(12, "CHF")); // (1)
      Assert.assertTrue(!m12CHF.equals(m14CHF));
}
}

　　当要同时�q�行��试Add和equals�Ҏ��Ӟ��可以��它们的各自的初始化工作�Q�合�q�到一赯��行，形成��试基础,用setUp初始化，用tearDown清除。如下：
public class MoneyTest extends TestCase {//TestCase的子�c?BR> private Money f12CHF;//提取公用的对�?BR> private Money f14CHF;

protected void setUp() {//初始化公用对�?BR>       f12CHF= new Money(12, "CHF");
      f14CHF= new Money(14, "CHF");
}
public void testEquals() {//��试equals�Ҏ��的正��?BR>       Assert.assertTrue(!f12CHF.equals(null));
      Assert.assertEquals(f12CHF, f12CHF);
      Assert.assertEquals(f12CHF, new Money(12, "CHF"));
      Assert.assertTrue(!f12CHF.equals(f14CHF));
}

public void testSimpleAdd() {//��试add�Ҏ��的正��?BR>       Money expected= new Money(26, "CHF");
      Money result= f12CHF.add(f14CHF);
      Assert.assertTrue(expected.equals(result));
}
}

　　��以上三个中的�Q一个TestCase子类代码保存到名为MoneyTest.java的文仉��Q��ƈ在文仉��行增�?BR>import junit.framework.*;
�Q�都是可以运行的。关于Junit�q�行的问题很有意思，下面单独说明�?BR>　　上面��释概念“测试基��(fixture)”，引入了两个对两个�Ҏ��的测试。命令模式与集成模式的本质区别是�Q�前者一�ơ只�q�行一个测试�?BR>
集成模式
　　利用TestSuite可以��一个TestCase子类中所有test***()�Ҏ��包含�q�来一赯��行，�q�可��TestSuite子类也包含进来，从而行成了一�U�等�U�关�p�R��可以把TestSuite视�ؓ一个容器，可以盛放TestCase中的test***()�Ҏ��Q�它自己也可以嵌套。这�U�体�p�L��构，非常�c�M��于现实中�E�序一步步开发一步步集成的现��c�?BR>　　对上面的例子�Q�有代码如下�Q?BR>public class MoneyTest extends TestCase {//TestCase的子�c?BR> ....
public static Test suite() {//静态Test
      TestSuite suite= new TestSuite();//生成一个TestSuite
      suite.addTest(new MoneyTest("testEquals")); //加入��试�Ҏ��
      suite.addTest(new MoneyTest("testSimpleAdd"));
      return suite;
}
}

　　从Junit2.0开始，有列��L��Ҏ��:
public class MoneyTest extends TestCase {//TestCase的子�c?BR> ....
public static Test suite() {静态Test
      return new TestSuite(MoneyTest.class); //以类为参�?BR> }
}

　　TestSuite见嵌套的例子�Q�在后面应用案例中有�?BR>　　

4、测试代码的�q�行
　　先说最常用的集成模式�?BR>　　��试代码写好以后�Q�可以相应的�c�M��写main�Ҏ��Q�用java命��o直接�q�行�Q�也可以不写main�Ҏ��Q�用Junit提供的运行器�q�行。Junit提供了textui,awtui和swingui三种�q�行器�?BR>　　以前面第2步中的AllTests�q�行��Z��Q�可有四�U�：

java junit.textui.TestRunner junit.samples.AllTests
java junit.awtui.TestRunner junit.samples.AllTests
java junit.swingui.TestRunner junit.samples.AllTests
java junit.samples.AllTests

　　main�Ҏ��中一般也都是��单地用Runner调用suite()�Q�当没有main�Ӟ��TestRunner自己以运行的�c�Mؓ参数生成了一个TestSuite.
　　
　　对于命��o模式的运行，有两�U�方法�?BR>
静态方�?BR>
TestCase test= new MoneyTest("simple add") {
public void runTest() {
testSimpleAdd();
}
};

动态方�?BR>
TestCase test= new MoneyTest("testSimpleAdd");

　　我试了一下，好象有问题，哪位朋友成功了，��h��Ҏ��一下。确实可以�?BR>
import junit.framework.*;

public class MoneyTest extends TestCase {//TestCase的子�c?BR> private Money f12CHF;//提取公用的对�?BR> private Money f14CHF;
public MoneyTest(String name){
      super(name);
}
protected void setUp() {//初始化公用对�?BR>       f12CHF= new Money(12, "CHF");
      f14CHF= new Money(14, "CHF");
}
public void testEquals() {//��试equals�Ҏ��的正��?BR>       Assert.assertTrue(!f12CHF.equals(null));
      Assert.assertEquals(f12CHF, f12CHF);
      Assert.assertEquals(f12CHF, new Money(12, "CHF"));
      Assert.assertTrue(!f12CHF.equals(f14CHF));
}

public void testAdd() {//��试add�Ҏ��的正��?BR>       Money expected= new Money(26, "CHF");
      Money result= f12CHF.add(f14CHF);
      Assert.assertTrue(expected.equals(result));
}
// public static void main(String[] args) {
//       TestCase test=new MoneyTest("simple add") {
//             public void runTest() {
//                   testAdd();
//             }
//          };
//       junit.textui.TestRunner.run(test);
// }
public static void main(String[] args) {
      TestCase test=new MoneyTest("testAdd");
      junit.textui.TestRunner.run(test);
}
}

再给一个静态方法用集成��试的例子：
public static Test suite() {
TestSuite suite= new TestSuite();
suite.addTest(
      new testCar("getWheels") {
         protected void runTest() { testGetWheels(); }
      }
);

suite.addTest(
      new testCar("getSeats") {
         protected void runTest() { testGetSeats(); }
      }
);
return suite;
}

5、应用案�?BR>

Junit Primer例程�Q�运行如下：
java com.hedong.JunitLearning.Primer.ShoppingCartTest

Ant+Junit+Mailto实现自动�~�译、调试�ƈ发送结果的build.xml

JUnit实施,写得很棒�Q�理解也深刻。例�E�运行如下：
java com.hedong.JunitLearning.car.testCarNoJunit
java junit.swingui.TestRunner com.hedong.JunitLearning.car.testCar

Junit与log4j�l�合�Q�阿菜的例程�q�行�Q?BR>cd acai
ant junit

6、一些问�?BR>　　有�h在实践基��上�ȝ��Z��些非常有价值的使用技巧，我没有经�q�一一“测试”，暂列在此�?BR>
不要用TestCase的构造函数初始化Fixture�Q�而要用setUp()和tearDown()�Ҏ��?BR>
不要依赖或假定测试运行的��序�Q�因为JUnit利用Vector保存��试�Ҏ��。所以不同的�q�_��会按不同的顺序从Vector中取出测试方法。不�?.8中是不是�q�是如此�Q�不�q�它提供的例子有一个是指定用VectorSuite的，如果不指定呢�Q?BR>
避免�~�写有副作用的TestCase。例如：如果随后的测试依赖于某些特定的交易数据，��׃��要提交交易数据。简单的回滚��可以了�?BR>
当��承一个测试类�Ӟ��记得调用父类的setUp()和tearDown()�Ҏ��?BR>
��测试代码和工作代码攑֜�一��P��一边同步编译和更新。（使用Ant中有支持junit的task.�Q?BR>
��试�c�d��试�Ҏ��应该有一致的命名�Ҏ��。如在工作类名前加上test从而�Ş成测试类名�?BR>
��保��试与时间无养I��不要依赖使用�q�期的数据进行测试。导致在随后的维护过�E�中很难重现��试�?BR>
如果你编写的软�g面向国际市场�Q�编写测试时要考虑国际化的因素。不要仅用母语的Locale�q�行��试�?BR>
��可能地利用JUnit提供地assert/fail�Ҏ��以及异常处理的方法，可以使代码更为简�z��?BR>
��试要尽可能地小�Q�执行速度快�?BR>
把测试程序徏立在与被��对象相同的包中

在你的原始代码目录中避免��试码出玎ͼ�可在一个源码镜像目录中放测试码

在自��q��应用�E�序包中包含一个TestSuite��试�c?BR>

7、相兌��源下�?BR>以下jar包，我只是做了打包、编译和调试的工作，供下载学习之用，相关的权利属于原作者�?BR>
可运行例�E?jar

Build.xml

阿菜的例�E?BR>
Junit API 汉译(pdf)

8、未完成的�Q�?BR>

httpunit

cactus

��Junit用链接池��试

主要参考文献：

JUnit入門
[url]http://www.dotspace.twmail.org/Test/JUnit_Primer.htm[/url]

怎样使用Junit Framework�q�行单元��试的编�?BR>[url]http://www.chinaunix.net/bbsjh/14/546.html[/url]

Ant+Junit+Log4J+CVS�q�行XP模式开发的建立
[url]http://ejb.cn/modules/tutorials/printpage.php?tid=4[/url]

用HttpUnit��试Web应用�E�序
[url]http://www.zdnet.com.cn/developer/code/story/0[/url],2000081534,39033726,00.htm

有没有用�q�Cactus的，Web层的��试是Cactus�q�是JUnit�Q?BR>[url]http://www.jdon.com/jive/thread.jsp?forum=16&thread=9156[/url]

Ant+junit的测试自动化 biggie�Q�原作）
[url]http://www.csdn.net/Develop/article/19%5C19748.shtm[/url]

JUnit实施
[url]http://www.neweasier.com/article/2002-08-07/1028723459.html[/url]

JUnitTest Infected: Programmers Love Writing Tests
[url]http://junit.sourceforge.net/doc/testinfected/testing.htm[/url]

JUnit Cookbook
[url]http://junit.sourceforge.net/doc/cookbook/cookbook.htm[/url]

JUnit Primer
[url]http://www.itu.dk/~lthorup/JUnitPrimer.html[/url]

IBM DevelopWorks
[url]http://www-106.ibm.com/search/searchResults.jsp?query=junit&searchScope=dW&[/url]
searchType=1&searchSite=dWChina&pageLang=zh&langEncoding=gb2312&Search.x=0&
Search.y=0&Search=Search

黑石 2005-12-20 18:02 发表评论