BlogJava-JAVA进行式-文章分类-学习笔记

在开发中使用ant

水秀清灵 — Sat, 05 Aug 2006 02:18:00 GMT

说明：
下面是我在开发中使用的build.xml文件以及其附属文件，为使层次清晰我将公用任务放入common.xml中，另外还有一些配置文件，这个build.xml会在今后开发中不断完善。

1、build.xml文件

        2、common.xml文件

               username="${tomcat.username}"
           password="${tomcat.password}"
           path="/${webapp.name}"/>

              username="${tomcat.username}"
          password="${tomcat.password}"
          path="/${webapp.name}"/>

              username="${tomcat.username}"
          password="${tomcat.password}"/>

               target="1.5" source="1.5" debug="true"
           deprecation="true" optimize="false" failonerror="true">



















                      encoding="UTF-8"
                  src="${classes.dir}" includes="**/*_zh.properties"/>

              preservelastmodified="true">




              preservelastmodified="true">






              preservelastmodified="true">

      +----------------------------------------------------------+
      |    -- Welcome to the AppDemo New Application Wizard! -- |
      |                                                          |
      | To create a new application, please answer the following |
      | questions.                                               |
      +----------------------------------------------------------+




               addproperty="app.name" defaultvalue="myapp"/>


      Creating new application named '${app.name}'...

















        3、webapp.properties文件
src.dir=src
build.dir=WebRoot
webpage.dir=${build.dir}/webpage
webinf.dir=${build.dir}/webinf
lib.dir=${webinf.dir}/lib
classes.dir=${webinf.dir}/classes

        4、tomcatTasks.properties文件
deploy=org.apache.catalina.ant.DeployTask
install=org.apache.catalina.ant.InstallTask
list=org.apache.catalina.ant.ListTask
reload=org.apache.catalina.ant.ReloadTask
remove=org.apache.catalina.ant.RemoveTask
resources=org.apache.catalina.ant.ResourcesTask
roles=org.apache.catalina.ant.RolesTask
start=org.apache.catalina.ant.StartTask
stop=org.apache.catalina.ant.StopTask
undeploy=org.apache.catalina.ant.UndeployTask

        5、tomcat.properties文件
tomcat.server=localhost
tomcat.manager.url=http://${tomcat.server}/manager
tomcat.username=admin
tomcat.password=

水秀清灵 2006-08-05 10:18 发表评论

eclipse在oracle安装后启动不了的解决办法

水秀清灵 — Sun, 30 Jul 2006 01:37:00 GMT

当oracle安装后，会自动在环境变量path中加上哦oracle的路径，例如：G:\oracle\ora92\bin;C:\Program Files\Oracle\jre\1.3.1\bin;C:\Program Files\Oracle\jre\1.1.8\bin;三个值，因而影响eclipse启动时查找jre。有三种办法解决启动不了的问题： 1、由于eclipse启动时会首先找自己目录下的jre,因此可以简单的把jre复制到eclipse下解决这个问题，例如：本机为：D:\eclipse-SDK-3.1.1-win32\eclipse下 2、首先配置JAVA_HOME(JDK的安装路径),然后设置eclipse的启动参数(-vm),用来指定你所用的jdk,点击eclipse的启动快捷方式鼠标右键->"属性"->"目标"，改为： jdkD:\eclipse-SDK-3.1.1-win32\eclipse\eclipse.exe -vm "%JAVA_HOME%\bin\javaw.exe 3、修改系统的环境变量，把原来的jdk的bin路径加到path的最前面，去掉oracle的jre路径： C:\Program Files\Oracle\jre\1.3.1\bin;C:\Program Files\Oracle\jre\1.1.8\bin;

水秀清灵 2006-07-30 09:37 发表评论

JAVA面试题（一）

水秀清灵 — Tue, 28 Mar 2006 15:58:00 GMT

1、heap和stack有什么区别？
    栈（stack)，是限定仅在表尾进行插入或删除操作的线性表，栈的修改是按照后进先出（LIFO）原则进行的，因此栈又称为后进先出线性表。在java中栈驻留于常规RAM（随机访问存储器）区域，可通过“栈指针”获得处理的直接支持。栈指针若向下移，会创建新的内存；若向上移，则会释放那些内存。这是一种特别快、特别有效的数据保存方式，仅次于寄存器。创建程序时，Java编译器必须准确地知道栈内保存的所有数据的“长度”以及“存在时间”。这是由于它必须生成相应的代码，以便向上和向下移动指针。这一限制无疑影响了程序的灵活性，所以尽管有些Java数据要保存在堆栈里，如对象的引用（句柄）、局部变量、形式参数等，但java对象并不放在其中。
    堆（heap），是一种常规用途的内存池（也在RAM区域），其中保存了Java对象。和栈不同之处在于，堆的存储空间是在程序执行过程中动态分配的，编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间。因此，用堆保存数据时会得到更大的灵活性。要求创建一个对象时，只需用new命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存。当然，为达到这种灵活性，必然会付出一定的代价：在堆里分配存储空间时会花掉更长的时间！

2、error和exception的区别？
    error是指与系统有关的错误，这种错误一般是不可恢复，或恢复起来很困难的，如内存溢出错误，是不可能由程序来处理的。
    exception是指在程序执行过程中发生的，需要程序捕获和处理的运行时错误，在程序运行正常的情况下，是不会发生的。当JAVA程序违反了JAVA的语义规则时，JAVA虚拟机就会将发生的错误表示为一个异常。违反语义规则包括2种情况。一种是JAVA类库内置的语义检查。如数组下标越界,会引发IndexOutOfBoundsException;访问null的对象时会引发NullPointerException。另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。所有的异常都是java.lang.Thowable的子类。

3、如果系统要使用超大整数（超过long长度范围），请你设计一个数据结构来存储这种超大型数字以及设计一种算法来实现超大整数加法运算）。
public class BigInt {

    /** 用于保存超大整数 */
    private int[] intArr = null;

    /** 无参构造方法构造一个初始化为0的大数 */
    public BigInt() {
        this("0");
    }

    /** 构造一个带参大数 */
    public BigInt(String s) {
        if(intArr != null) {
            intArr = null;
        }
        setArr(s);
    }

    /** 设置大数 */
    public void setArr(String s) {
        intArr = new int[s.length()];
        for(int i=0;i            int intTemp = s.charAt(i) - '0';
            if(intTemp <= 9) {
                intArr[i] = intTemp;
            }
        }
    }

    /** 取得数的字符串类型的表示 */
    public String getArr() {
        StringBuffer strBuf = new StringBuffer();
        for(int i=0; i            strBuf.append(intArr[i]);
        }
        return strBuf.toString();
    }

    /** 返回数的大小 */
    private int length() {
        int len = 0;
        if(intArr != null) {
            len = intArr.length;
        }
        return len;
    }

    private static BigInt fillZero(BigInt arr, int int0){
        BigInt temp = arr;
        for(int i=0; i            temp = new BigInt("0" + temp.getArr());
        }
        return temp;
    }

    /** 对两个BigInt型对象做加法运算，返回结果为BigInt型 */
    public static BigInt add(BigInt one, BigInt two) {
        BigInt arrSum = null;
        BigInt arr = null;

        if(one.intArr.length > two.intArr.length) {
            arrSum = one;
            arr = fillZero(two, one.intArr.length - two.intArr.length);
        } else if(one.intArr.length == two.intArr.length) {
            arrSum = two;
            arr = one;
        } else {
            arr = two;
            arrSum = fillZero(one, two.intArr.length - one.intArr.length);
        }

        int i=arr.intArr.length-1;
        for(; i>=1; i--){
            int intTemp = arrSum.intArr[i] + arr.intArr[i];
            arrSum.intArr[i] = intTemp%10;
            if(intTemp>9){
                arrSum.intArr[i-1] = arrSum.intArr[i-1] + intTemp/10;
            }
        }

        int intTemp = arrSum.intArr[0] + arr.intArr[0];
        arrSum.intArr[i] = intTemp%10;
        if(intTemp>9){
            return new BigInt("1" + arrSum.getArr());
        } else {
            return arrSum;
        }
     }

     /** 程序入口，格式化输出 */
     public static void main(String[] args) {
         try {
             BigInt one = new BigInt(args[0]);
             System.out.println(" " + one.getArr());
             BigInt two = new BigInt(args[1]);
             System.out.println("+ " + two.getArr());
             System.out.println("----------------------------");
             BigInt sum = BigInt.add(one, two);
             System.out.println(" " + sum.getArr());
         } catch(java.lang.ArrayIndexOutOfBoundsException e) {
             System.out.println("数组下标越界");
      }
   }
}

水秀清灵 2006-03-28 23:58 发表评论

java的内伤

水秀清灵 — Fri, 20 Jan 2006 15:04:00 GMT

Java吸引了越来越多的商业机构和软件开发商，但在赢得最终胜利之前Java还需要克服一些主要障碍。

最近的研究表明微软公司开发的编程技术仍然是软件开发商采用的最重要语言。但Java正在逐步地拉近同微软编程语言的距离。根据2000年度IDC研究报告，当时有300万人在使用C 和C++ 作为自己的主要编程语言，Visual Basic开发人员有230万，Java开发人员则只有120万。市场研究公司Evans Data则报告说，使用Java的人越来越多，而 C和C++开发人员的数量则在显著减少。

这一趋势在学术界也得到了反映。在麻省理工学院，计算机科学系早在1997年就用Java 取代了微软的C++作为学生必须掌握的主要软件语言。今年春季，加州大学伯克利分校就开设了25门Java课程，而针对微软编程语言的课程只有7门。麻省理工学院的副教授Daniel Jackson说：“照我看，Java将很快取代其他所有的编程语言，尤其是C++。”这位学者提醒注意，大学生甚至在上Java课程之前就在逐渐地自学Java了。在2年的时间里，学院将把针对高中生开设的大学级学分课程的高级测验由C++转到Java。

但是，甚至在面临如此令人鼓舞的迹象同时，分析家和软件公司官员仍然认为若干因素会阻碍Java的成长。第一个可想而知，这就是同微软公司之间展开的、不可避免的竞争，微软已经发布了称为C#的编程语言，C#非常类似Java，而且它还推出了一个部分模拟Java的Internet软件策略。

第2个障碍来自Java阵营的内部，很多软件公司所发布的产品并不遵守业内达成的一致标准。尽管大大小小的软件不兼容最后都会得到一定的处理，但是，Java的支持者们害怕这种不受约束的软件开发可能会引发混乱和潜在的冲突，结果令这项技术的开发者们无所适从。

最后，Java自身的复杂性也一直是一个问题。分析家说，为了突破掌握高级开发技能的程序员的狭窄范围而令主流开发者接受Java，软件制造商不得不在易用编程工具领域被微软牵着鼻子走：允许程序员只需要点按鼠标之类的操作即可开发Java程序。特别地，他们对称为企业Enterprise Java Bean标准大加批评，该标准实际上是通过重用小部分软件来节约开发时间。更容易使用的Java工具将有助于增加使用这一语言的软件开发者数量，从而产生越来越大而且越来越健康的Java市场。 Giga信息集团的分析员Mike Gilpin声称：“要博得开发者和独立软件供应商的青睐就必须考虑以上的问题。”

自从Sun Microsystems公司在7年前发明Java技术至今，软件开发程序员普遍接受了Java，首先是应用于网站建设，其后又进入了企业因特网和电子商务领域。今天，Java又在诸如蜂窝电话、在线游戏、股票信息等、餐馆定位乃至实时信息处理等新兴市场中大展身手。

尽管Java最初目标是取代PC上占霸主地位的Windows，而且这一目标完全失败了，但是，拥趸Java的阵营已经能让Java技术得到尽可能地普及。Java今天的成功部分地归于开发者和客户，其实，他们仅仅希望世界上除了微软还应该有其他选择，微软巴不得从手持设备到企业服务器，在任何设备上都最好运行着Windows。

作为反对Windows霸权阵营的一员，Sun发誓要让Java运行在任何设备上，而且所有的程序都不必重写，这就是赫赫有名的“只写一次，处处可行”原则，显然该原则同微软坚持世界上只有它的操作系统这一战略是完全对立的。Java很快就赢得了其他微软之敌的支持，比如IBM、Oracle和BEA Systems等。

然而，这种编程语言实际上并没在完全实现多重设备上运行同一代码的承诺。结果，商业机构这才觉察到，相比它们在选择Java时所做的估计，现在花得的时间和金钱比预想的多得多。

Meta集团分析员Zachmann评价说：“‘只写一次，处处可行’这条原则在服务器端压根就没有起过作用。”

许多人认为这个问题源自Java标准的通过被拖延得太久，这个标准花了12到18个月的时间才完成。软件开发商又面临着争取新客户的竞争压力所以无法等待那么长的时间。因此它们只能定期地改进和发布基于非标准技术的Java软件。

大多数的Java软件开发商把它们的尖端技术提交给Java Community Process，这是一个由Sun和其它Java公司参与发起的组织，负责研究和制定未来的Java技术标准。如果提交的技术得到了标准认可，其他的软件开发商就可以采用这一技术了。但是当新标准真被制定出来的时候，Java公司却又发明出了虽然不是标准但却给它们带来竞争力的新技术。

为了在有利可图的电子商务软件市场获取有利地位，BEA、IBM和其它Java软件开发商都摆弄出了如此之多的非标准技术并应用在们的应用服务器和其他产品之中，使之运行更快而且更可靠。这样一来，客户不得不关心兼容性的问题，能在某Java开发商的应用服务器上运行的软件却不能100%在其他开发商的产品上运行。

Iona公司产品主任Simon Pepper认为：“我们不得不关注这一不兼容事实，我相信，正是这一原因使Java陷入分裂状态而且令Java开发者感到无所适从，所谓的‘编写一次，处处可行’的目标并没有实现。结果令Java在兼容性能上的良好形象大大受损。同时却为微软打开了攻城夺地的方便之门。如果技术是分裂的，而且开发商也是分裂的，这肯定会令开发者怀疑Java是否真是一种优秀的技术。”

摘自：http://www.zdnet.com.cn

水秀清灵 2006-01-20 23:04 发表评论

Java 编码规范(三) 文件格式

水秀清灵 — Sun, 11 Dec 2005 10:50:00 GMT

Java程序一个类一个文件，文件名以类名命名，我想这个大家都知道吧，那么关于java源代码文件的格式还有什么要注意的呢？看看人家怎么说的吧：

1、版权信息，必须在 java 文件的开头，比如：

     /*
      * Copyright ? 2000 Shanghai XXX Co. Ltd.
      * All right reserved.
      */

其他不需要出现在 javadoc 的信息也可以包含在这里。

2、Package/Imports
package 行要在 import 行之前，import 中标准的包名要在本地的包名之前，而且按照字母顺序排列。如果 import 行中包含了同一个包中的不同子目录，则应该用 * 来处理。

         package hotlava.net.stats;

         import java.io.*;
         import java.util.Observable;
         import hotlava.util.Application

这里 java.io.* 使用来代替InputStream and OutputStream 的。
（关于这点，有点疑问，我知道详细的写出引用类的路径及类名，可以较快的搜索到要引用的类，可是一个包中要引用的类过多的话，是不是用*来处理，比全部写出来好哩？全部写出来会很长，不方便阅读，不过现在的IDE大都有收缩功能，问题也不大吧？）

         3、对类的注释（解释类的功能），采用文档注释，写在类声明之前。例如：

          /**
           * A class representing a set of packet and byte counters
           * It is observable to allow it to be watched, but only
           * reports changes when the current set is complete
           */

         接下来是类定义的格式，包含了在不同的行的 extends 和 implements

      public class CounterSet
		         extends Observable
		         implements Cloneable



     （这样写呀，第一次看到，我想我不太喜欢这种写法，这也是规范吗？）

         4、类的成员变量，在声明之前也要用文档注释说明其意义。例如：

         /**
          * Packet counters
          */
         protected int[] packets;

         public 的成员变量必须生成文档（JavaDoc）。proceted、private和 package 定义的成员变量如果名字含义明确的话，可以没有注释。
         （因为public的成员变量是类的接口，是供用户程序员使用的，所以必须生成文档，所以必须用文档注释标注）
         5、类变量的存取的方法，在其声明之前也要用文档注释说明其意义。
         若它只是简单的用来将类的变量赋值获取值的话，可以简单的写在一行上。例如：

     /**
      * Get the counters
      * @return an array containing the statistical data.  This array has been
      * freshly allocated and can be modified by the caller.
      */
      public int[] getPackets() { return copyArray(packets, offset); }
      public int[] getBytes() { return copyArray(bytes, offset); }

      public int[] getPackets() { return packets; }
      public void setPackets(int[] packets) { this.packets = packets; }

   
             其它的方法不要写在一行上。

         6、构造函数，应该用递增的方式写（比如：参数多的写在后面）。
         访问类型 ("public", "private" 等.) 和 任何 "static", "final" 或 "synchronized" 应该在一行中，并
且方法和参数另写一行，这样可以使方法和参数更易读。





         public
         CounterSet(int size){
              this.size = size;
         }
         （这么写？不习惯，保留意见）
         7、克隆方法，如果一个类是可以被克隆的，那么在定义类时应该重写其继承的 clone 方法：
     public
     Object clone() {
       try {
          CounterSet obj = (CounterSet)super.clone();
          obj.packets = (int[])packets.clone();
          obj.size = size;
          return obj;
       }catch(CloneNotSupportedException e) {
          throw new InternalError("Unexpected CloneNotSUpportedException: " 
                                 + e.getMessage());
       }
     }

8、类方法（定义为final或static的，类而非其实例对象所拥有的方法），例如：

     /**
      * Set the packet counters
      * (such as when restoring from a database)
      */
      protected final
      void setArray(int[] r1, int[] r2, int[] r3, int[] r4)
                    throws IllegalArgumentException
      {
        //
        // Ensure the arrays are of equal size
        //
        if (r1.length != r2.length || r1.length != r3.length || r1.length != r4.length)
	   throw new IllegalArgumentException("Arrays must be of the same size");
        System.arraycopy(r1, 0, r3, 0, r1.length);
        System.arraycopy(r2, 0, r4, 0, r1.length);
      }





    9、toString 方法，每一个类都应该对继承自Object类的 toString 方法进行重写：
           public
      String toString() {
        String retval = "CounterSet: ";
        for (int i = 0; i < data.length(); i++) {
            retval += data.bytes.toString();
            retval += data.packets.toString();
        }
        return retval;
      }
 
    10、main 方法 
      如果main(String[]) 方法已经定义了, 那么它应该写在类的底部. 
      （这样子的？为什么把main（）方法写在类的一开始不好哩？）

水秀清灵 2005-12-11 18:50 发表评论

Java 编码规范(二) 排版规范

水秀清灵 — Sun, 11 Dec 2005 09:10:00 GMT

上次记录了一些编写上的规范，这回看看排版有些什么规矩：

1、关键词和操作符之间加适当的空格。（这个我知道，比如“i+j=x;”应该写成“i + j = x;”，这样看起来是不是漂亮多了！)

2、相对独立的程序块与块之间加空行。（嗯，这样便于阅读，方法与方法之间空行，方法内部也应该根据语句内容自然空行）。

3、较长的语句、表达式等要分成多行书写（对呀，屏幕显示有限）。划分出的新行要进行适应的缩进，使排版整齐，语句可读。

4、长表达式要在低优先级操作符处划分新行，操作符放在新行之首。（有道理，在低优先级操作符处断行，不会过于影响代码的阅读理解，将操作符放在新行之首也是这个道理）

5、循环、判断等语句中若有较长的表达式或语句，则要进行适应的划分。（这个，怎么划分哩？）

         6、若函数或过程中的参数较长，则要进行适当的分行。（是的，分行时应该将参数的类型放在新行之首，且要有适当的缩进，比如可以与上一行的参数对齐，这样阅读清晰、方便）

         7、不允许把多个短语句写在一行中，即一行只写一条语句。（嗯，对于“int i，j，x；”这样的语句是不是分成三行，一行一句更好些，尤其在它做为类的成员变量时）

         8、函数或过程的开始、结构的定义及循环、判断等语句中的代码都要采用缩进风格。

         9、C/C++语言是用大括号‘{’和‘}’界定一段程序块的，编写程序块时‘{’和 ‘}’应各独占一行并且位于同一列，同时与引用它们的语句左对齐。在函数体的开始、类的定义、结构的定义、枚举的定义以及if、for、do、while、switch、case语句中的程序都要采用如上的缩进方式。
         （呵呵，这里怎么说的是C和C++语言？不是在讲java 的编码规范吗？不过，这个问题一直困扰着我，C和C++语言中这种打括号的形式，我觉得很好，符合人们的阅读习惯，哪个“{”和哪个“}”是一对儿的，一目了然，使代码的层次非常清晰。然而我在绝大多数的java 语言代码，包括sun公司所给的JFC源代码中看到的都是下列格式：
         public void myMethod（）{
               int i = 2;
               ......
         }
         这是为什么哩？java的“始作蛹者”（好象的贬义词，开个玩笑）当初是出于什么考虑哩？甚至有的老师把它做为“地道的java”程序的标志。虽然我不喜欢这种书写形式，可是既然大家都这么写，是不是我也应该遵循这种“约定俗成”的格式哩？

水秀清灵 2005-12-11 17:10 发表评论

Java 编码规范(一) 程序编写规范

水秀清灵 — Sun, 11 Dec 2005 07:58:00 GMT

         今天把以前收集的“java  编码规范”找出来读一读，写了几个月代码了，虽然零零星星知道一些关于java的编码规范，可是不是很系统，昨天看到组员写的代码，直观感觉上很不舒服，觉得写得很不符合编码规范，看上去不好看，阅读起来很困难，想给他讲一讲，突然意识到自己也不是很说的清楚，OK，来看看人家是怎么阐述这个编码规范问题吧！
         那么什么是编码规范呢？
         编码规范就是使用一种语言编写代码时，要遵守的一些约定俗成，或是长期经验总结而成的规矩，这些规矩并不是一定要执行的，也就是说，不执行它，程序照样能编译通过，照样能运行起来，那么我们为什么要去遵守它呢？这是因为我们编写的程序并不仅仅是只给自己一个人看的，在现代软件开发中，往往是由多个人共同完成软件的开发工作，由一个人独立完成大型软件的开发工作，几乎是不可能的。而且在软件开发完成，进入到软件维护阶段后，对软件的维护工作也很可能是由其他人员来进行。那么，编写出的代码就需要多个人去阅读。如果每个人都按照自己的习惯去写代码，就会给其他读代码的人造成很大的困扰，从而影响他对程序的理解、判断，影响他对程序的所进行的维护和改进工作。那么有了编码规范，大家都遵循统一的规范去做，就会大大提高代码的可读性，使开发人员能够迅速而彻底的理解代码，从而提高工作效率。另外，遵守编码规范对于我们编写代码的人来说，也是有利的，随着程序的复杂程度的加深，我们所编写的代码行逐步增多，如果没有在一开始严格遵守规范，而是随性编写，那么在后期也会对我们自己阅读代码造成影响，而且更为严重的是，降低了代码的健壮性，使代码变得容易出错，而不易维护了。
         基于上述原因，做为一个合格程序员，严格遵守编码规范是基本条件。
         先来说说“程序编写规范”，实际上这个标题是“java编码规范”的第一章节的标题，看了内容，感觉不太恰当，可是一时又不知道改什么名好，就照着他的来吧。
         1、exit() 除了在 main() 中可以被调用外，其他的地方不应该被调用。
         这样做是因为不给任何代码截获退出的机会。比如，一个类似后台服务的程序不应该因为某一个库模块决定了要退出就退出。
         2、声明的错误应该抛出一个RuntimeException或者其派生的异常。顶层的main()函数应该截获所有的异常，并且打印（或者记录在日志中）在屏幕上。
         3、java使用成熟的后台垃圾收集技术来代替引用计数。但是，请记住，java的垃圾收集技术只会对内存中的“垃圾”进行清理，而不会对其他资源，诸如：数据库、磁盘、打印机等进行清理工作。因此你必须在使用完这些对象的实例以后进行清场工作。比如：
         FileOutputStream fos = new FileOutputStream(projectFile);
         project.save(fos, "IDE Project File");
         fos.close();      //对文件输出流对象进行关闭（清场工作）
         4、Clone，下面是一种有用的方法：
        implements Cloneable
        public Object clone()
        {
            try
            {
                 ThisClass obj = (ThisClass)super.clone();
                 obj.field1 = (int[])field1.clone();
                 obj.field2 = field2;
                 return obj;
            }
            catch(CloneNotSupportedException e)
            {
                 throw new InternalError("Unexpected CloneNotSUpportedException: " + e.getMessage());
            }
         }
         这里……我不太看得明白他所写的意思，对于clone()方法我大概知道它是java的根类Object中的一个方法，其作用是创建并返回一个当前对象的拷贝，即是“克隆”一个和当前对象一模一样的另一个对象。那么Cloneable是什么？查了API帮助，知道了，Cloneable是一个接口，只有实现了这个Cloneable接口的类的实例才可以用继承自Object类的clone()方法进行“克隆”，没有实现这个接口的类的实例若调用clone()方法，则会抛出“CloneNotSupportedException”异常。不过，好奇怪，查看了它的源代码，仅仅有一个接口名字，没有声明任何的方法或是常量，基本类库中为什么会有这样一个接口哩？既然所有的类都直接或间接继承自Object类，那为什么还要用一个Cloneable接口来限制其子类能否进行“克隆”操作哩？现在还弄不明白。
         3、final 类，绝对不要因为性能的原因将类定义为 final 的（除非程序的框架要求）。
         最好在类文档中注明一个类目前不能被继承，而不要将它定义为 final 的。因为没有人可以保证会不会由于什么原因需要继承它。（那么，尽量少用final类，呵呵，到目前为止我还没用到过final类，真想知道什么时候一定会用到final类，好象没有地方需要呀）
          4、访问类的成员变量，大部分的类成员变量应该定义为 protected 的来防止继承类使用他们。
          这里……我又不明白了，记得学java的访问权限修饰符时，protected修饰的类成员，仅在类内和类的派生类中可见，把类成员定义为protected，怎么能够防止继承类（派生类）使用哩？如果定义为private，才可能不被继承类使用吧？我错了吗？
         5、对于数组的声明，要用“int[] packets”，而不是“int packets[]”，后一种永远也不要用。
         这个……，对于后一种，java中好象没有硬性规定不可以用（C#中倒是只承认前一种声明数组的形式），但写成前一种形式，更具意义一些。

水秀清灵 2005-12-11 15:58 发表评论

实现工具栏滚动显示的方法

水秀清灵 — Tue, 29 Nov 2005 15:18:00 GMT

        工具栏ToolBar中可加入如JLabel、JPanel、JButton或JComboBox等很多可视化组件的对象，且默认为FlowLayout布局管理器，有时候因为编程的需要，我们要往里面插入很多个组件，如何显示出完整的组件列表成了一个问题，而ToolBar的对象放在JScrollPane对象中是显示不出来的，原因是它和JPanel一样是没有边框的，我的解决办法是，将要插入到工具栏的对象先放入集合中（如果全是相同类型的对象，放在数组中保存更好），再通过for循环依次加入到ToolBar对象中，在ToolBar外面设置一个按钮，编写响应该按钮的点击事件，当该按钮被点击一次时，通过数组下标（或集合索引）从ToolBar中remove（）去掉一个组件，并调用revalidate（）方法，让紧跟其后的组件移上去，添补删除后留下的空白，并把删除的那个组件重新用add（）方法追加到工具栏尾部，这样循环删除和添加，就实现了工具栏的滚动效果，由于工具栏的FlowLayout布局，使它在未设置时只能向一个方向添加组件，故我的这个工具栏的滚动效果是单向的。
        对于两向滚动，我考虑在反向滚动前重新设置工具栏的布局管理器，以改变其添加组件的方向，从而达到双向滚动的效果。具体能否实现，有待进一步编码检测。
        在这里我把单向滚动的源代码记录如下：

/**DiaryEditToolBarPane类构建一个包含一个工具栏和一个控制滚动的按钮 */

public class DiaryEditToolBarPane extends JPanel implements ActionListener
{
JTextPane jTextPane;
DiaryEditToolBar diaryEditToolBar;
JPanel jPanelSouth = new JPanel();
JButton jButtonUp = new JButton(ConstValue.IMG_UP);
//JButton jButtonDn = new JButton(ConstValue.IMG_DN);

public DiaryEditToolBarPane(JTextPane jTextPane)
{
  this.jTextPane = jTextPane;
  diaryEditToolBar = new DiaryEditToolBar(this.jTextPane);

  jButtonUp.setMargin(new Insets(0,0,0,0));
  //jButtonDn.setMargin(new Insets(0,0,0,0));
  jButtonUp.setActionCommand("up");
  //jButtonDn.setActionCommand("down");
  //jPanelSouth.setLayout(new GridLayout(2,1));
  jPanelSouth.add(jButtonUp);
  //jPanelSouth.add(jButtonDn);

  this.setLayout(new BorderLayout());
  this.add(diaryEditToolBar,BorderLayout.CENTER);
  this.add(jPanelSouth, BorderLayout.SOUTH);

  jButtonUp.addActionListener(this);
  //jButtonDn.addActionListener(this);
}

public void setTextPane(JTextPane jTextPane)
{
  this.jTextPane = jTextPane;
  diaryEditToolBar.setTextPane(this.jTextPane);
}

public void actionPerformed(ActionEvent e)
{
  if(e.getActionCommand().equals("up"))
  {
   diaryEditToolBar.moveUp();
  }
  /*
  else if(e.getActionCommand().equals("down"))
  {
   diaryEditToolBar.moveDown();
  }*/
}
}

/**定义一个具体实现工具栏组件布局与滚动的类DiaryEditToolBar  */

public class DiaryEditToolBar extends JToolBar
{
/**用于保存工具按钮的对象数组*/
private BrimlessButton[] toolBarButton;
/**工具按钮增、删索引值*/
private static int index = 0;

private void init()
{
  this.setFloatable(false);
  BrimlessButton[] temp =
  {
   toolBarButtonSave,toolBarButtonSave,toolBarButtonCut,
   toolBarButtonCopy,toolBarButtonPaste,toolBarButtonFontStyle,
   toolBarButtonFontSize,toolBarButtonFontForeground,toolBarButtonBackground,
   toolBarButtonBold,toolBarButtonItalic,toolBarButtonUnderline,
   toolBarButtonFlusLeft,toolBarButtonCenter,toolBarButtonFlushRight,
   toolBarButtonUndo,toolBarButtonRedo,toolBarButtonIndentLeft,
   toolBarButtonIndentRight,toolBarButtonURL,toolBarButtonImage,
   toolBarButtonDateTime
  };
  toolBarButton = temp;

  for(int i=0; i<22; i++)
  {
   this.addElement(toolBarButton[i]);
  }
}

private void addElement(JButton jButton)
{
  this.add(jButton);
}

private void delElement(JButton jButton)
{
  this.remove(jButton);
}

/**删除工具栏开头的工具按钮，并将其添加到工具栏末尾，以实现工具栏向上滚动的效果*/
public void moveUp()
{
  delElement(toolBarButton[index]);
  this.revalidate();
  addElement(toolBarButton[index]);
  index = (++index)%22;
}

/**增加工具栏开头的工具按钮，以实现工具栏向下滚动的效果*/
public void moveDown()
{
  //addElement(toolBarButton[index]);
  //this.revalidate();
  //repaint();
}
}

水秀清灵 2005-11-29 23:18 发表评论

如何完全保存JTextPane中编辑的文本和图片的方法

水秀清灵 — Tue, 29 Nov 2005 14:51:00 GMT

JTextPane类的对象可以显示文本、图片和超链接等，在创建了一个JTextPane类的纯文本格式对象后，可以向里面填写入文字（英文或汉字等）、插入超链接或图片，但无法通过getText()方法获得其中除文字以外的内容，也即无法保存包含文字、图片和超链接的完全对象内容，而如果一开始创建的是JTextPane类的HTML格式对象，则虽然可以保存文字的样式（颜色和字体、字号等）但无法再通过insertIcon（）方法插入、显示图片，更不能直接保存了，考虑到的解决思路：①通过手工在HTML文件中插入语句来实现对图片的保存，可是这样比较不容易实现，需要将图片保存在特定位置，才可以在下次打开JTextPane类对象是显示出图片；②创建JTextPane类的纯文本对象，在插入图片、超链接、设置字体样式或其它任何对JTextPane类的对象进行的格式设置时均记录下设置的位置和内容，并和文本内容一起保存到硬盘文件中，下次读取时，按照记录重新恢复原内容，实现的过程更复杂；③将JTextPane对象通过对象序列化的方式在硬盘中保存为一个文件，下次读取时再反序列化为完整对象。
最后，选择了最好实现的第三种方法，序列化了JTextPane对象，表现出来的效果不错。不过，在实现过程中未考虑程序的运行效率，现在也不太清楚，这样的处理方式是不是比较没有效率哩？

水秀清灵 2005-11-29 22:51 发表评论