序列化是什么：
序列化就是将一个对象的状态（各个属性量）保存起来，然后在适当的时候再获得。
序列化分为两大部分：序列化和反序列化。序列化是这个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据的对象实例


序列化的什么特点：
如果某个类能够被序列化，其子类也可以被序列化。声明为static和transient类型的成员数据不能被序列化。因为static代表类的状态， transient代表对象的临时数据。
public interface Serializable (API5.0)

类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。

要允许不可序列化类的子类型序列化，可以假定该子类型负责保存和还原超类型的公用 (public)、受保护的 (protected) 和（如果可访问）包 (package) 字段的状态。仅在子类型扩展的类有一个可访问的无参数构造方法来初始化该类的状态时，才可以假定子类型有此责任。如果不是这种情况，则声明一个类为可序列化类是错误的。该错误将在运行时检测到。

在反序列化过程中，将使用该类的公用或受保护的无参数构造方法初始化不可序列化类的字段。可序列化的子类必须能够访问无参数的构造方法。可序列化子类的字段将从该流中还原。

当遍历一个图形时，可能会遇到不支持可序列化接口的对象。在此情况下，将抛出 NotSerializableException，并将标识不可序列化对象的类。

在序列化和反序列化过程中需要特殊处理的类必须使用下列准确签名来实现特殊方法：

 private void writeObject(java.io.ObjectOutputStream out)
throws IOException
private void readObject(java.io.ObjectInputStream in)
throws IOException, ClassNotFoundException;

writeObject 方法负责写入特定类的对象的状态，以便相应的 readObject 方法可以还原它。通过调用 out.defaultWriteObject 可以调用保存 Object 的字段的默认机制。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。

readObject 方法负责从流中读取并还原类字段。它可以调用 in.defaultReadObject 来调用默认机制，以还原对象的非静态和非瞬态字段。defaultReadObject 方法使用流中的信息来分配流中通过当前对象中相应命名字段保存的对象的字段。这用于处理类发展后需要添加新字段的情形。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。

将对象写入流时需要指定要使用的替代对象的可序列化类，应使用准确的签名来实现此特殊方法：

 ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;

此 writeReplace 方法将由序列化调用，前提是如果此方法存在，而且它可以通过被序列化对象的类中定义的一个方法访问。因此，该方法可以拥有私有 (private)、受保护的 (protected) 和包私有 (package-private) 访问。子类对此方法的访问遵循 java 访问规则。

在从流中读取类的一个实例时需要指定替代的类应使用的准确签名来实现此特殊方法。

 ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

此 readResolve 方法遵循与 writeReplace 相同的调用规则和访问规则。

序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。可序列化类可以通过声明名为 "serialVersionUID" 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID：

 ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;

如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值，如“Java(TM) 对象序列化规范”中所述。不过，强烈建议 所有可序列化类都显式声明 serialVersionUID 值，原因计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException。因此，为保证 serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修改器显示声明 serialVersionUID（如果可能），原因是这种声明仅应用于立即声明类 -- serialVersionUID 字段作为继承成员没有用处

实用意义:
         一：对象序列化可以实现分布式对象。主要应用例如：RMI要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。
二：java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传递。利用对象序列化可以进行对象的“深复制”，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。

EP:
import java.io.Serializable;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.FileInputStream;
import java.io.ObjectInputStream;

class MeTree implements Serializable {
 private static final long serialVersionUID = 42L;
 public MeTree left;
 public MeTree right;
 public int  id;
 public int level;
    private static int count  =   0 ; 

    public  MeTree( int  depth)   {
          id  = count ++ ;
          level  =  depth;
         if  (depth  >   0 )   {
         
            left  =   new  MeTree(depth - 1 );
            right  =   new  MeTree(depth - 1 );
        } 
     }
 
     public   void  print( int  levels)   {
         for  ( int  i  =   0 ; i  <  level; i ++ ) {
            System.out.print( "    " );
        System.out.println( " node  "   +  id);
       
         if  (level  <=  levels  &&  left  !=   null )
            left.print(levels); 

         if  (level  <=  levels  &&  right  !=   null )
            right.print(levels);
         }
     }

     public   static   void  main (String argv[])   {

         try    {
             /**/ /* 创建一个文件写入序列化树。 */ 
            FileOutputStream ostream  =   new  FileOutputStream( " MeTree.tmp " );
             /**/ /* 创建输出流 */ 
            ObjectOutputStream p  =   new  ObjectOutputStream(ostream);

             /**/ /* 创建一个二层的树。 */ 
            MeTree base  =   new  MeTree( 2 );

            p.writeObject(base);  // 将树写入流中。
             p.writeObject( " LiLy is 惠止南国 " );
            p.flush();
            ostream.close();     // 关闭文件。
 
              /**/ /* 打开文件并设置成从中读取对象。 */ 
            FileInputStream istream  =   new  FileInputStream( " MeTree.tmp " );
            ObjectInputStream q  =   new  ObjectInputStream(istream);

             /**/ /* 读取树对象，以及所有子树 */ 
            MeTree new_MeTree  =  (MeTree)q.readObject();

            new_MeTree.print( 2 );   // 打印出树形结构的最上面 ２级
             String name  =  (String)q.readObject();
            System.out.println( " \n " + name);
        }   catch  (Exception ex)   {
            ex.printStackTrace();
        } 
     }
}

可以看到，在序列化的时候，writeObject与readObject之间的先后顺序。readObject将最先write的object read出来。用数据结构的术语来讲就姑且称之为先进先出吧！
在序列化时，有几点要注意的：
　  １：当一个对象被序列化时，只保存对象的非静态成员变量，不能保存任何的成员方法和静态的成员变量。
　　２：如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存。
　　３：如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化操作将会失败，并且会抛出一个NotSerializableException。我们可以将这个引用标记为transient，那么对象仍然可以序列化

还有我们对某个对象进行序列化时候，往往对整个对象全部序列化了，比如说类里有些数据比较敏感，不希望序列化，一个方法可以用transient来标识，另一个方法我们可以在类里重写 

可以通过指定关键transient使对象中的某个数据元素不被还原，这种方式常用于安全上的保护。比如对象中保存的密码。
//**
transient 只能用在类的成员变量上,不能用在方法里. 
transient 变量不能是final和static的

transient（临时）关键字
控制序列化过程时，可能有一个特定的子对象不愿让Java的序列化机制自动保存与恢复。一般地，若那个子对象包含了不想序列化的敏感信息（如密码），就会面临这种情况。即使那种信息在对象中具有“private”（私有）属性，但一旦经序列化处理，人们就可以通过读取一个文件，或者拦截网络传输得到它。
为防止对象的敏感部分被序列化，一个办法是将自己的类实现为Externalizable，就象前面展示的那样。这样一来，没有任何东西可以自动序列化，只能在writeExternal()明确序列化那些需要的部分。
然而，若操作的是一个Serializable对象，所有序列化操作都会自动进行。为解决这个问题，可以用transient（临时）逐个字段地关闭序列化，它的意思是“不要麻烦你（指自动机制）保存或恢复它了——我会自己处理的”。
例如，假设一个Login对象包含了与一个特定的登录会话有关的信息。校验登录的合法性时，一般都想将数据保存下来，但不包括密码。为做到这一点，最简单的办法是实现Serializable，并将password字段设为transient。

password被设为transient，所以不会自动保存到磁盘；另外，自动序列化机制也不会作恢复它的尝试。

一旦对象恢复成原来的样子，password字段就会变成null。注意必须用toString()检查password是否为null，因为若用过载的“+”运算符来装配一个String对象，而且那个运算符遇到一个null句柄，就会造成一个名为NullPointerException的违例（新版Java可能会提供避免这个问题的代码）。
我们也发现date字段被保存到磁盘，并从磁盘恢复，没有重新生成。
由于Externalizable对象默认时不保存它的任何字段，所以transient关键字只能伴随Serializable使用。

**//　还有我们对某个对象进行序列化时候，往往对整个对象全部序列化了，比如说类里有些数据比较敏感，不希望序列化，一个方法可以用transient来标识，另一个方法我们可以在类里重写

1、实现Serializable会导致发布的API难以更改，并且使得package-private和private
这两个本来封装的较好的咚咚也不能得到保障
2、Serializable会为每个类生成一个序列号，生成依据是类名、类实现的接口名、
public和protected方法，所以只要你一不小心改了一个已经publish的API，并且没有自
己定义一个long类型的叫做serialVersionUID的field，哪怕只是添加一个getXX，就会
让你读原来的序列化到文件中的东西读不出来（不知道为什么要把方法名算进去？）
3、不用构造函数用Serializable就可以构造对象，看起来不大合理，这被称为
extralinguistic mechanism，所以当实现Serializable时应该注意维持构造函数中所维
持的那些不变状态
4、增加了发布新版本的类时的测试负担
5、1.4版本后，JavaBeans的持久化采用基于XML的机制，不再需要Serializable6、设计用来被继承的类时，尽量不实现Serializable，用来被继承的interface也不要
继承Serializable。但是如果父类不实现Serializable接口，子类很难实现它，特别是
对于父类没有可以访问的不含参数的构造函数的时候。所以，一旦你决定不实现
Serializable接口并且类被用来继承的时候记得提供一个无参数的构造函数
7、内部类还是不要实现Serializable好了，除非是static的，(偶也觉得内部类不适合
用来干这类活的)
8、使用一个自定义的序列化方法
  看看下面这个保存一个双向链表的例子：



publicclass StringList implementsSerializable
{
?privateint size = 0;
?private Entry head = null;
?
?privatestaticclass Entry implements Serializable
?{
? String data;
? Entry next;
? Entry previous;
?}
?...//Remainder ommitted
}

这样会导致链表的每个元素以及元素之间的关系（双向链表之间的连接）
都保存下来，更好的方法是提供一个自定义的序列化如下：
//String List with a resonable custom serialized form
class StringList implementsSerializable
{
? privatetransientint size = 0;?????? //!transient
? privatetransient Entry head = null;? //!transient
? 
? //no longer serializable!
? privatestaticclass Entry
? {
??? String data;
??? Entry next;
??? Entry previous;
? }
? 
? //Appends the specified string to the list
? publicvoid add(String s) {/*...*/};
? 
? /**
?? * Serialize this StringList instance 
?? * @author yuchifang
?? * @serialData The size of the list (the number of strings
   * it contains) is emitted(int), in the proper sequence
?? */
? privatevoid writeObject(ObjectOutputStream s)
throws IOException
? {
??? s.defaultWriteObject();
??? s.writeInt(size);
??? //Write out all elements in the proper order
??? for (Entry e = head; e != null; e = e.next)
????? s.writeObject(e.data);
? }
? 
? privatevoid readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException
? {
??? int numElements = s.readInt();
??? 
??? //Read in all elements andd insert them in list
??? for (int i = 0; i < numElements; i++)
????? add((String)s.readObject());
? }
? //...remainder omitted
}
9、不管你选择什么序列化形式，声明一个显式的UID：
private static final long serialVersionUID = randomLongValue;10、不需要序列化的东西使用transient注掉它吧，别什么都留着
11、writeObject/readObject重载以完成更好的序列化
readResolve 与 writeReplace重载以完成更好的维护invariant controllers


  完全定制序列化过程:

如果一个类要完全负责自己的序列化，则实现Externalizable接口而不是Serializable接口。Externalizable接口定义包括两个方法writeExternal()与readExternal()。利用这些方法可以控制对象数据成员如何写入字节流.类实现Externalizable时，头写入对象流中，然后类完全负责序列化和恢复数据成员，除了头以外，根本没有自动序列化。这里要注意了。声明类实现Externalizable接口会有重大的安全风险。writeExternal()与readExternal()方法声明为public，恶意类可以用这些方法读取和写入对象数据。如果对象包含敏感信息，则要格外小心。这包括使用安全套接或加密整个字节流。到此为至，我们学习了序列化的基础部分知识。关于序
列化的高级教程，以后再述。

Package 的命名
Package 的名字應該都是由一個小寫單詞組成。

Class 的命名
Class 的名字必須由大寫字母開頭而其他字母都小寫的單詞組成

Class 變數的命名
變數的名字必須用一個小寫字母開頭。後面的單詞用大寫字母開頭。

Static Final 變數的命名
Static Final 變數的名字應該都大寫，並且指出完整含義。

參數的命名
參數的名字必須和變數的命名規範一致。

陣列的命名
陣列應該總是用下面的方式來命名：
byte[] buffer;    
而不是：
byte buffer[];
    
方法的參數
使用有意義的參數命名，如果可能的話，使用和要賦?的欄位一樣的名字：
1234
 SetCounter(int size)
{ 
this.size = size;
}

Java 文件樣式
所有的 Java(*.java) 文件都必須遵守如下的樣式規則
版權資訊
版權資訊必須在 java 文件的開頭，比如：

/** * Copyright R 2000 XXX Co. Ltd. * All right reserved. */    
其他不需要出現在 javadoc 的資訊也可以包含在這?。

Package/Imports
package 行要在 import 行之前，import 中標準的包名要在本地的包名之前，而且按照字母順序排列。如果 import 行中包含了同一個包中的不同子目?，則應該用 * 來處理。
123
 package hotlava.net.stats;
import java.io.*;
import java.util.Observable;import hotlava.util.Application; 

 
  
這兒java.io.* 使用來代替InputStream and OutputStream 的。
Class
接下來的是類的注釋，一般是用來解釋類的。
1
 /** * 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
1
 public class CounterSet   extends Observable implements Cloneable 

 
  
Class Fields

接下來是類的成員變數：
123
 
/** * Packet counters */
protected int[] packets;

public 的成員變數必須生成文?（JavaDoc）。proceted、private和 package 定義的成員變數如果名字含義明確的話，可以沒有注釋。

存取方法
接下來是類變數的存取的方法。它只是簡單的用來將類的變數賦?獲取?的話，可以簡單的寫在一行上。
12345678910111213
 
/** * 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;
 }

其他的方法不要寫在一行上

構造函數
接下來是構造函數，它應該用遞增的方式寫（比如：參數多的寫在後面）。
訪問類型 ("public", "private" 等.) 和 任何 "static", "final" 或 "synchronized" 應該在一行中，並且方法和參數?寫一行，這樣可以使方法和參數更易讀。
1234
 public CounterSet
(int size){ 
this.size = size;
}

克隆方法
如果這個類是可以被克隆的，那?下一?就是 clone 方法：
12345678910111213
 
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()); 
}
}

類方法
下面開始寫類的方法：
12345678
 /** * Set the packet counters * (such as when restoring from a database) */
protected finalvoid 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);
}

toString 方法
無論如何，?一個類都應該定義 toString 方法：
12345678910
 public String toString()
{ 
String retval = "CounterSet: ";  
 for (int i = 0; i < data.length(); i++) {    
   retval += data.bytes.toString();
      retval += data.packets.toString();
   }   
return retval; 
}
}

main 方法
如果main(String[]) 方法已經定義了, 那?它應該寫在類的底部.
代碼編寫格式

代碼樣式
代碼應該用 unix 的格式，而不是 windows 的（比如：回車變成回車+換行）

文?化
必須用 javadoc 來爲類生成文?。不僅因爲它是標準，這也是被各種 java 編譯器都認可的方法。使用 @author 標記是不被推薦的，因爲代碼不應該是被個人擁有的。

縮進
縮進應該是?行2個空格. 不要在原始?案中保存Tab字元. 在使用不同的源代碼管理工具時Tab字元將因爲用?設置的不同而擴展爲不同的寬度.
如果?使用 UltrEdit 作爲?的 Java 源代碼編輯器的話，?可以通過如下操作來禁止保存Tab字元, 方法是通過 UltrEdit中先設定 Tab 使用的長度室2個空格，然後用 Format|Tabs to Spaces 功能表將 Tab 轉換爲空格。

頁寬
頁寬應該設置爲80字元. 源代碼一般不會超過這個寬度, 並導致無法完整顯示, 但這一設置也可以靈活調整. 在任何情況下, 超長的語句應該在一個逗號或者一個操作符後折行. 一條語句折行後, 應該比原來的語句再縮進2個字元.

{} 對
{} 中的語句應該單獨作爲一行. 例如, 下面的第1行是錯誤的, 第2行是正確的:
12
 if (i>0) { i ++ };
// 錯誤, { 和 } 在同一行

1234
  if (i>0) {
 i ++
 };
 // 正確, { 單獨作爲一行 } 語句永遠單獨作爲一行.

如果 } 語句應該縮進到與其相對應的 { 那一行相對齊的位置。

括弧
左括弧和後一個字元之間不應該出現空格, 同樣, 右括弧和前一個字元之間也不應該出現空格. 下面的例子?明括弧和空格的錯誤及正確使用:
12
 CallProc( AParameter ); // 錯誤
CallProc(AParameter); // 正確

不要在語句中使用無意義的括弧. 括弧只應該爲達到某種目的而出現在源代碼中。下面的例子?明錯誤和正確的用法:
12
 if ((I) = 42) { // 錯誤 - 括弧毫無意義
if (I == 42) or (J == 42) then // 正確 - 的確需要括弧

程式編寫規範
exit()
exit 除了在 main 中可以被調用外，其他的地方不應該調用。因爲這樣做不給任何代碼代碼機會來截獲退出。一個類似後臺服務地程式不應該因爲某一個庫模組決定了要退出就退出。

異常
申明的錯誤應該抛出一個RuntimeException或者派生的異常。
頂層的main()函數應該截獲所有的異常，並且列印（或者記?在日誌中）在螢幕上。

??收集
JAVA使用成熟的後臺??收集技術來代替引用計數。但是這樣會導致一個問題：?必須在使用完物件的實例以後進行清場工作。比如一個prel的程式師可能這?寫：
1234
   ...  {
    FileOutputStream fos = new FileOutputStream(projectFile);
    project.save(fos, "IDE Project File");
   }  ...

除非輸出流一出作用域就關閉，非引用計數的程式語言，比如JAVA，是不能自動完成變數的清場工作的。
必須象下面一樣寫：
  FileOutputStream fos = new FileOutputStream(projectFile);
  project.save(fos, "IDE Project File");
  fos.close();
Clone
下面是一種有用的方法：
1234567891011
   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());
      }
 }

final 類
?對不要因爲性能的原因將類定義爲 final 的（除非程式的框架要求）
如果一個類還沒有準備好被繼承，最好在類文?中注明，而不要將?定義爲 final 的。這是因爲沒有人可以保證會不會由於什?原因需要繼承?。

訪問類的成員變數
大部分的類成員變數應該定義爲 protected 的來防止繼承類使用他們。
注意，要用"int[] packets"，而不是"int packets[]"，後一種永遠也不要用。
1234567
 
public void setPackets(int[] packets) {
this.packets = packets;
}
 CounterSet(int size){
this.size = size;
}

 

文件构成	文件路径	模块位置	文件应当属于他所在的模块（serivce,dao…… ）目录。	●
		机能位置	文件属于他所对应的机能目录。	●
命名规则	包名	包名	首字母小写，名词方式或者编号方式命名	●
	类名	类名	首字母大写，单词第一个字母大写。	●
	常量	常量	定义为静态（static），定义为终结（final）			●
		常量名	常量名全部使用大写，单词间使用（_）分割			●
	方法名	无返回值方法名	首字母小写，机能方式命名。			●
		其他类型方法名	首字母小写	●
		Boolean型方法名	is+形容词，can+动词，has+名词/动词过去式			●
	变量名	Boolean型变量名	is+形容词，can+动词，has+名词/动词过去式			●
		其他类型变量名	首字母小写	●
	英文	拼写正确	英语单词拼写正确	●
	对称性	命名单词对称	add/remove insert/delete insert/delete start/stop begin/end ……			●
	循环用变量	循环用变量命名	根据使用次序按照i j k l m n 依次使用	●
	临时变量	临时变量命名	使用该变量类型每个单词的首字母小写命名，如（ServeletContext sc;） 使用该变量类型名，将该名称首字母小写，如（Array array; 或者 Array arr;）	●
	方法参数	方法参数命名	定义方式参照变量名定义。参数名能够表示该参数的含义。	●
	内部变量	内部变量命名	用于保存公开变量（publci String getXXX()）的内部变量，使用XXX作为变量名命名（但首字母要小写）
编程样式	注释	注释方式	单行注释使用"//"+空格+注释内容。多行注释使用/*...*/。	●
	缩进方式	缩进方式	使用1个tab进行缩进处理	●
	括号方式	类	起始括号位于类定义行末尾，结束括号单独一行，与类定义对齐。	●
		方法	起始括号位于方法定义行末尾，结束括号单独一行，与方法定义对齐。	●
		程序分支	起始括号位于分支定义行末尾，结束括号单独一行，与分支定义对齐。	●
	行的长度	行的长度	每行程序的长度不得超过80个字符。	●
	private	使用范围	除去公开方法或者属性外，应当全部定义为private。	●
	protected	使用范围	共通类/方法以外，没有特殊要求，不得使用protected定义。	●
	public	使用范围	允许外部访问和修改的方法/变量。	●
	if/while	"="符号的使用	在if/while语句的判断式内，不能使用"="符号。	●
		"< > <= >="的使用	在同一个判断式中的多个部分内，不允许同时出现"<"和">"（判断方向必须一致）	●
	循环处理	循环处理嵌套	循环处理不允许嵌套3层以上。	●
	循环变量	循环变量	不允许多个循环代码使用同一个变量作为循环参数。	●
	文件注释	注释方式	使用多行注释	●
		改版履历	式样变更的改版履历，内容有（时间，式样版本，对应者）			●
	类注释	注释方式	使用多行注释	●
		机能说明	对机能进行简单说明。	●
		创建者	记录创建者（@author）	●
	方法注释	注释方式	使用多行注释	●
		机能说明	对机能进行简单说明。		●
		参数说明	对参数和返回值进行简单说明。		●
	变量注释	注释方式	使用单行注释	●
其他	判断式	判断式	使用"< > = && ||"等判断式组成多次组合判断时，使用括号标明判断式执行次序。	●

三：线程的四种状态
1. 新状态：线程已被创建但尚未执行（start() 尚未被调用）。
2. 可执行状态：线程可以执行，虽然不一定正在执行。CPU 时间随时可能被分配给该线程，从而使得它执行。
3. 死亡状态：正常情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。
4. 阻塞状态：线程不会被分配 CPU 时间，无法执行。

四：线程的优先级
线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 CPU 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间，优先级高的线程有更大的机会获得 CPU 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。
你可以调用 Thread 类的方法 getPriority() 和 setPriority()来存取线程的优先级，线程的优先级界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之间，缺省是5(NORM_PRIORITY)。

五：线程的同步
由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问
由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。
1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如
public synchronized void accessVal(int newVal);
synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方
法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。
在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。
synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。
2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：
synchronized(syncObject) {
//允许访问控制的代码
}
synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。
六：线程的阻塞
为了解决对共享存储区的访问冲突，Java 引入了同步机制，现在让我们来考察多个线程对共享资源的访问，显然同步机制已经不够了，因为在任意时刻所要求的资源不一定已经准备好了被访问，反过来，同一时刻准备好了的资源也可能不止一个。为了解决这种情况下的访问控制问题，Java 引入了对阻塞机制的支持。
阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。
1. sleep() 方法：sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。
典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止。
2. suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume() 使其恢复。
3. yield() 方法：yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程。
4. wait() 和 notify() 方法：两个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式，一种允许 指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用。
初看起来它们与 suspend() 和 resume() 方法对没有什么分别，但是事实上它们是截然不同的。区别的核心在于，前面叙述的所有方法，阻塞时都不会释放占用的锁（如果占用了的话），而这一对方法则相反。
上述的核心区别导致了一系列的细节上的区别。
首先，前面叙述的所有方法都隶属于 Thread 类，但是这一对却直接隶属于 Object 类，也就是说，所有对象都拥有这一对方法。初看起来这十分不可思议，但是实际上却是很自然的，因为这一对方法阻塞时要释放占用的锁，而锁是任何对象都具有的，调用任意对象的 wait() 方法导致线程阻塞，并且该对象上的锁被释放。而调用 任意对象的notify()方法则导致因调用该对象的 wait() 方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行）。
其次，前面叙述的所有方法都可在任何位置调用，但是这一对方法却必须在 synchronized 方法或块中调用，理由也很简单，只有在synchronized 方法或块中当前线程才占有锁，才有锁可以释放。同样的道理，调用这一对方法的对象上的锁必须为当前线程所拥有，这样才有锁可以释放。因此，这一对方法调用必须放置在这样的 synchronized 方法或块中，该方法或块的上锁对象就是调用这一对方法的对象。若不满足这一条件，则程序虽然仍能编译，但在运行时会出现IllegalMonitorStateException 异常。
wait() 和 notify() 方法的上述特性决定了它们经常和synchronized 方法或块一起使用，将它们和操作系统的进程间通信机制作一个比较就会发现它们的相似性：synchronized方法或块提供了类似于操作系统原语的功能，它们的执行不会受到多线程机制的干扰，而这一对方法则相当于 block 和wakeup 原语（这一对方法均声明为 synchronized）。它们的结合使得我们可以实现操作系统上一系列精妙的进程间通信的算法（如信号量算法），并用于解决各种复杂的线程间通信问题。
关于 wait() 和 notify() 方法最后再说明两点：
第一：调用 notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这种不确定性而产生问题。
第二：除了 notify()，还有一个方法 notifyAll() 也可起到类似作用，唯一的区别在于，调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然，只有获得锁的那一个线程才能进入可执行状态。
谈到阻塞，就不能不谈一谈死锁，略一分析就能发现，suspend() 方法和不指定超时期限的 wait() 方法的调用都可能产生死锁。遗憾的是，Java 并不在语言级别上支持死锁的避免，我们在编程中必须小心地避免死锁。
以上我们对 Java 中实现线程阻塞的各种方法作了一番分析，我们重点分析了 wait() 和 notify() 方法，因为它们的功能最强大，使用也最灵活，但是这也导致了它们的效率较低，较容易出错。实际使用中我们应该灵活使用各种方法，以便更好地达到我们的目的。

七：守护线程
守护线程是一类特殊的线程，它和普通线程的区别在于它并不是应用程序的核心部分，当一个应用程序的所有非守护线程终止运行时，即使仍然有守护线程在运行，应用程序也将终止，反之，只要有一个非守护线程在运行，应用程序就不会终止。守护线程一般被用于在后台为其它线程提供服务。
可以通过调用方法 isDaemon() 来判断一个线程是否是守护线程，也可以调用方法 setDaemon() 来将一个线程设为守护线程。

八：线程组
线程组是一个 Java 特有的概念，在 Java 中，线程组是类ThreadGroup 的对象，每个线程都隶属于唯一一个线程组，这个线程组在线程创建时指定并在线程的整个生命期内都不能更改。你可以通过调用包含 ThreadGroup 类型参数的 Thread 类构造函数来指定线程属的线程组，若没有指定，则线程缺省地隶属于名为 system 的系统线程组。
在 Java 中，除了预建的系统线程组外，所有线程组都必须显式创建。
在 Java 中，除系统线程组外的每个线程组又隶属于另一个线程组，你可以在创建线程组时指定其所隶属的线程组，若没有指定，则缺省地隶属于系统线程组。这样，所有线程组组成了一棵以系统线程组为根的树。
Java 允许我们对一个线程组中的所有线程同时进行操作，比如我们可以通过调用线程组的相应方法来设置其中所有线程的优先级，也可以启动或阻塞其中的所有线程。
Java 的线程组机制的另一个重要作用是线程安全。线程组机制允许我们通过分组来区分有不同安全特性的线程，对不同组的线程进行不同的处理，还可以通过线程组的分层结构来支持不对等安全措施的采用。Java 的 ThreadGroup 类提供了大量的方法来方便我们对线程组树中的每一个线程组以及线程组中的每一个线程进行操作。

九：总结
在这一讲中，我们一起学习了 Java 多线程编程的方方面面，包括创建线程，以及对多个线程进行调度、管理。我们深刻认识到了多线程编程的复杂性，以及线程切换开销带来的多线程程序的低效性，这也促使我们认真地思考一个问题：我们是否需要多线程？何时需要多线程？
多线程的核心在于多个代码块并发执行，本质特点在于各代码块之间的代码是乱序执行的。我们的程序是否需要多线程，就是要看这是否也是它的内在特点。
假如我们的程序根本不要求多个代码块并发执行，那自然不需要使用多线程；假如我们的程序虽然要求多个代码块并发执行，但是却不要求乱序，则我们完全可以用一个循环来简单高效地实现，也不需要使用多线程；只有当它完全符合多线程的特点时，多线程机制对线程间通信和线程管理的强大支持才能有用武之地，这时使用多线程才是值得的

　　GB2312：GB2312码是中华人民共和国国家汉字信息交换用编码，全称《信息交换用汉字编码字符集－基本集》。主要用于给每一个中文字符指定相应的数字，也就是进行编码。一个中文字符用两个字节的数字来表示，为了和ASCII码有所区别，将中文字符每一个字节的最高位置都用1来表示。

　　GBK：为了对更多的字符进行编码，国家又发布了新的编码系统GBK(GBK的K是“扩展”的汉语拼音第一个字母)。在新的编码系统里，除了完全兼容GB2312 外，还对繁体中文、一些不常用的汉字和许多符号进行了编码。

　　ISO-8859-1：是西方国家所使用的字符编码集，是一种单字节的字符集 ，而英文实际上只用了其中数字小于128的部分。

　　Unicode：这是一种通用的字符集，对所有语言的文字进行了统一编码，对每一个字符都用2个字节来表示，对于英文字符采取前面加“0”字节的策略实现等长兼容。如 “a” 的ASCII码为0x61，UNICODE就为0x00，0x61。

　　UTF-8：Eight-bit UCS Transformation Format，(UCS，Universal Character Set，通用字符集，UCS 是所有其他字符集标准的一个超集)。一个7位的ASCII码值，对应的UTF码是一个字节。如果字符是0x0000，或在0x0080与0x007f之间，对应的UTF码是两个字节，如果字符在0x0800与0xffff之间，对应的UTF码是三个字节。

　　我们运行java程序时，JVM有自己所支持的编码种类，用以下代码可以看到：

Map m = Charset.availableCharsets();
   Set names = m.keySet();
   Iterator it = names.iterator();
   while (it.hasNext())
   {
    System.out.println(it.next());
   }

　　 然后可以通过以下代码看到我们目前JVM所使用的编码：

Properties pps = System.getProperties();
   pps.list(System.out);

　　具体来说什么是编码，什么是解码？
　　在InputStreamReader JDK有这样描述：It reads bytes and decodes them into characters using a specified charset.(用指定的字符集将字节数组解码成字符串)。
　　相反OutputStreamWriter 描述：Characters written to it are encoded into bytes using a specified charset.(用指定的字符集将字符串编码成字节数组)。

　　理解这个以后一切好办了啦！

　　我们的OS一般是GBK编码的（凡是从磁盘上读取文件可以看成是用OS的字符集编码方式来对操作对象进行解码处理--从标准输入设备读取数据的时候是依赖OS的字符集）。而我们将从磁盘上文件经过处理得到我们想要的字符串等其它对象的时候，这一过程是用JVM的默认的字符集编码方式来处理的！由于不同的字符集编码方式有着不同的原理(前面所述)，这样当编码与解码不一致的时候，自然而然就出现了可爱的乱码。

　　比如如下，将我们JVM字符集改成iso-8859-1这样在就与我们的OS不同：
　　当输入中文时自然就输出的是乱码了。

pps.put( " file.encoding " , " ISO-8859-1 " );
   int data;
   byte [] buf = new byte [ 100 ];
   int i = 0 ;
   while ((data = System.in.read()) != ' q ' )
   {
    buf[i] = ( byte )data;
    i ++ ;
   }
   String str = new String(buf, 0 ,i);
   System.out.println(str);

　
　　这时我们可以用string的一个构造方法：
　　String(byt[] bytes, String charsetName)
　　Constructs a new String by decoding the specified array of bytes using the specified charset.(用指定的字符集对字节数组进行解码)。
　　其中用到了string 的getBytes方法：
　　getBytes(String charsetName)
　　Encodes this String into a sequence of bytes using the named charset, storing the result into a new byte array.(用指定的字符集进行编码，将结果存放到一字节数组里面)重新构造一个string：

String strGBK = new String(str.getBytes( " ISO-8859-1 " ), " GBK " );

　　这样又可以重新得到我们想要的汉字了。

　　我们这例子中是GBK(OS)来编码的，然后采用iso-8859-1(JVM)来解码得到一个新string(此string是乱码)，然后将此string用iso-8859-1重新编码，并且用指定的GBK来解码。得到一个新string(也就是strGBK)，这个string就不再是乱码了。

　　但如果我们一开始就采用GBK解码得到的字符串，然后用ISO-8859-1编码，能否再解码回去得到我们的中文字符呢？显示不可以啦，因为用ISO-8859-1的编码的时候采用是一种单字节的字符集来对其编码，这样就丢失了一个字节(对中文来说)！所以这样是得不到中文字符的！

1 大前提：软件活动包含根本任务和次要任务

布鲁克斯指出：所有软件活动包括：

根本任务——打造构成抽象软件实体的复杂概念结构；

次要任务——使用编程语言表达这些抽象实体，并在时间和空间内将它们映射成机器语言。

2 小前提：现有解决方案致力于解决次要任务

考察和评估几乎现有所有的软件工程解决方案，布鲁克斯指出：现有所有方案全都在致力于解决软件工程中的次要问题。

3 结论：没有银弹

无论这些方案多么完善，都不可能在根本上解决问题，即使将全部次要任务的时间缩减到零，也不会带来生产率数量级上的提高。

应用孤岛问题：管理软件如何实施、应用的问题

由于基础架构的先天不足，现有的信息系统，无论是独立的工具软件还是集成的解决方案，大多是孤岛型的应用，或者是业务功能模块的简单累加。这些孤岛系统，相互之间是孤立封闭的

IT黑洞问题：管理软件如何设计、开发和维护的问题

现有信息系统的建设，是在底层的技术平台上直接构建业务系统，并且也只能采用面向技术的、业务无关的“原始”编程工具来开发管理系统 。这种低层次的软件开发模式，使信息系统的开发、维护和扩展困难重重，导致IT黑洞现象的普遍发生

import  org.apache.commons.lang.builder.HashCodeBuilder;
import  org.apache.commons.lang.builder.EqualsBuilder;

public   class  PoliticalCandidate  {
     //  Member variables - omitted for brevity
     //  Constructors - omitted for brevity
     //  get/set methods - omitted for brevity
     //  A hashCode which creates a hash from the two unique identifiers

     public   int  hashCode( )  {
         return   new  HashCodeBuilder( 17 ,  37 )
                       .append(firstName)
                       .append(lastName).toHashCode( );
    }

     //  An equals which compares two unique identifiers
     public   boolean  equals(Object o)  {
         boolean  equals  =   false ;
         if  ( o  !=   null   && PoliticalCandidate. class .isAssignableFrom(o) )  {
            PoliticalCandidate pc  =  (PoliticalCandidate) o;
            equals  =  ( new  EqualsBuilder( )
                       .append(firstName, ps.firstName)
                       .append(lastName, ps.lastName)).isEquals( );
        }
         return  equals;
    }

}

public   int  hashCode( )  {
     return  HashCodeBuilder.reflectionHashCode( this );
}

public   boolean  equals(Object o)  {
     return  EqualsBuilder.reflectionEquals( this , o);
}

问题提出：需要快速实现compareTo()方法
解决方法：使用CompareToBuilder提供的compareTo()方法。同样的CompareToBuilder也使用了反射机制。以下代码提供了一个compareTo()方法，用于比较两个对象所有的非static和非transient成员变量。

import  org.apache.commons.lang.builder.CompareToBuilder;

//  Build a compareTo function from reflection 
public   int  compareTo(Object o)  {
     return  CompareToBuilder.reflectionCompare( this , obj);

}

CompareToBuilder.reflectionCompare()提供了两个对象non-static和nontransient成员变量的方法。 reflectionCompare()方法不予理会static和transient变量，因此以下代码中的averageAge和fullName变量是不会进入比较表达式的。

public   class  PoliticalCandidate  {
     //  Static variable
     private   static  String averageAge;

     //  Member variables 
     private  String firstName;
     private  String lastName;

     private   transient  String fullName;
     //  Constructors
     //  get/set methods
     //  Build a compareTo function from reflection 
     public   int  compareTo(Object o)  {
         return  CompareToBuilder.reflectionCompare( this , obj);
    }

}

public   int  compareTo(Object o)  {
     int  compare  =   - 1 ;  //  By default return less-than
     if ( o  !=   null   &&  PoliticalCandidate. class .isAssignableFrom( o.getClass( ) ) )  {

            PoliticalCandidate pc  =  (PoliticalCandidate) o;
            compare  =  ( new  CompareToBuilder( )
                          .append(firstName, pc.firstName)
                          .append(lastName, pc.lastName)).toComparison( );
    }

     return  compare;
}

1.1 ReflectionToStringBuilder

本笔记是在阅读Jakarta Commons Cookbook时所留下的。
1.使用ReflectionToStringBuilder 或者ToStringBuilder 自动产生toString()的内容。
   使用举例：假设有一个表征校长候选人信息的javabean－PoliticalCandidate。
  

public class PoliticalCandidate {
    private String lastName;
    private String firstName;
    private Date dateOfBirth;
    private BigDecimal moneyRaised;
    private State homeState;

    // get/set方法省略
    public void toString( ) {
        ReflectionToStringBuilder.toString( this );
    }
}

该bean里面有个toString()方法，假设有以下操作：

// Create a State
State va = new State( "VA", "Virginia");

// Create a Birth Date
Calendar calendar = new GregorianCalendar( );
calendar.set( Calendar.YEAR, 1743 );
calendar.set( Calendar.MONTH, Calendar.APRIL );
calendar.set( Calendar.DAY_OF_MONTH, 13 );
Date dob = calendar.getTime( );

BigDecimal moneyRaised = new BigDecimal( 293829292.93 );        

// Create a Political Candidate
PoliticalCandidate candidate = 
    new PoliticalCandidate( "Jefferson", "Thomas", dob, moneyRaised, va );
     
System.out.println( candidate );

假设State对象也是一个使用ReflectionToStringBuilder的javabean，上述程序一种可能的输出为com.discursive.jccook.lang.builders.PoliticalCandidate@187aeca
    [lastName=Jefferson,\firstName=Thomas,
     dateOfBirth=Sat Apr 13 22:38:42 CST 1743,
     moneyRaised=\293829292.930000007152557373046875,
     state=\com.discursive.jccook.lang.builders.State@87816d
         [abbreviation=VA,name=Virginia]]

 

在IBM的developerWorks上有两篇非常优秀的关于JavaXML API的评测文章：

Java 中 XML 文档模型的性能

Java 中 XML 文档模型的用法

对这两篇文章我想说的就是 吐血推荐

Java的XML API这几篇文章该讲的都讲到了，我只想补充几点：

一、Crimson和Xerces恩仇录

Crimson来自于Sun捐赠给Apache的ProjectX项目，Xerces来自IBM捐赠给Apache的XML4J项目，结果Xerces胜出，成了Apache XML小组全力开发的XML API，而Crimon已经早就不做了，如今Xerces名满天下，到处都是在用Xerces DOM和SAX解析器，只有Sun不服气，非要在JDK1.4里面使用过时的Crimson，让人感觉像是在赌气一样，真是让人可怜又可气！不过IBM发行JDK用的XML 解析器自然是Xerces。

由于JDK的Class Loader的优先级关系，当你采用JAXP编写XML程序的时候，即使把Xerces包引入CLASSPATH，JDK还是会顽固的使用Crimson，这一点通过打开JVM的verbose参数可以观察到。不过JDK也允许你采用其它的解析器，因此我们可以通过在JRE\lib\目录下建一个jaxp.properties的文件，来替换解析器，jaxp.properties内容如下：

								javax.xml.parsers.DocumentBuilderFactory=org.apache.xerces.jaxp.DocumentBuilderFactoryImpl

javax.xml.parsers.SAXParserFactory=org.apache.xerces.jaxp.SAXParserFactoryImpl

这样就可以使用Xerces，当然你必须还是要把Xerces包放到CLASSPATH下。

二、JAXP的姗姗来迟

Sun在XML领域总是后知后觉，等到Sun重视XML的时候，XML的API早就满天 飞了，尤其是IBM具有非常大的领先优势。不过Sun是规范的制订者，于是参考W3C的标准制订了JAXP规范。JAXP不像Xerces和Crimon那样，它只是一个spec，本身是不做任何事情的，它的作用就是提出一个统一的接口，让其它的XML API都来遵循JAXP编程，那么用JAXP写出来的程序，底层的API可以任意切换。

具体来说JAXP包括了几个工厂类，这就是JDK1.4里面的javax.xml.parsers 包，用来寻找符合DOM标准的XML API实现类的位置；此外JAXP还包括一整套interface，这就是JDK1.4里面的org.w3c.dom那几个包。工厂类负责加载DOM的实现类。那么加载的规则是什么呢？

我是通过阅读JAXP的源代码知道的，工厂类首先会根据java命令行传入的参数进行寻找，然后在根据JRE\lib\jaxp.properties中定义的实现类寻找，最后什么都找不到的话，就用Crimson。注意Crimons是由Bootstrap Class Loader来load的，如果你不通过上面两个方法来改变工厂的寻找顺序，那么铁定用Crimson了 :(

三、DOM解析器和DOM API

当你严格采用JAXP编程的时候，是遵循W3C的DOm标准的，那么在JAXP底层你实际上可以任意切换不同的DOM实现，例如Xerces，或者Crimon，再或者其它，切换方法就是配置jaxp.properties。因此JAXP就是一些标准接口而已。

而Xerces和Crimon也不单单是一个DOM实现那么简单，他们本身实际上也包含SAX解析器和DOM解析器。所以一个JAXP程序下面有如下层次：

JAXP应用程序 -> JAXP接口 -> Xerces DOM实现 -> Xerces DOM/SAX 解析器

只要你用JAXP编程，那么你就可以切换到Crimson上来

JAXP应用程序 -> JAXP接口 -> Crimson DOM实现 -> Crimson DOM/SAX 解析器

另外你也可以这样来做：

JAXP应用程序 -> JAXP接口 -> Crimson DOM实现 -> Xerces DOM/SAX 解析器

不过如果你的程序不安装JAXP来写，那么就没有办法切换不同的DOM实现了。

四、不是标准的dom4j和jdom

W3C的DOM标准API难用的让人想撞墙，于是有一帮人开发Java专用的XML API目的是为了便于使用，这就是jdom的由来，开发到一半的时候，另一部分人又分了出来，他们有自己的想法，于是他们就去开发dom4j，形成了今天这样两个API，至于他们之间的性能，功能之比较看看上面我推荐的文章就知道了，jdom全面惨败。

jdom 相当于上面的 JAXP接口 ＋ Xerces DOM实现部分，它本身没有解析器，它可以使用Xerces或者Crimson的解析器，就是这样：

jdom应用程序 -> jdom API -> Xerces/Crimson解析器

dom4j 和jdom类似，不过他自己绑定了一个叫做Alfred2的解析器，功能不是很全，但是速度很快，当没有其它的解析器的时候，dom4j将使用Alfred2解析器，如下：

dom4j应用程序 -> dom4j API ->  Xerces/Crimson解析器

或者

dom4j应用程序 -> dom4j API ->  Alfred2解析器

你在SF上下载的dom4j.jar是不含 Alfred2解析器的，而dom4j-full.jar包含了 Alfred2解析器，在这种情况下，实际上你什么也不需要，光是一个dom4j-full.jar就全部都包括了。

因此可以看出采用dom4j/jdom编写的应用程序，已经不具备可移植性了。

五、小插曲

Sun是JAXP标准的制订者，甚至很执著的在JDK1.4里面绑定Crimson DOM实现和解析器，然后可笑的是，Sun自己的JAXM RI竟然不是用JAXP写出来的，而是dom4j，制订标准让大家遵守，自己却监守自盗，这未免太说不过去了吧！

BTW: Hibernate也用的是dom4j来读取XML配置文件，如今已经越来越多的程序纷纷采用dom4j，如果你不是那么在乎可移植性，我强烈建议你采用dom4j。