很多人覺得自己寫得 Java 程式碼中，新建的 pojo 物件要實現序列化是為了要儲存到硬碟上，其實呢，實現序列化和儲存到硬碟上沒有必然的關係。

以下圖舉例：

假設左邊的是你的電腦，也就是客戶端，右邊的是伺服器。之前你的客戶端和伺服器可能都在同一個電腦上，都是 Windows 下，那麼右邊的伺服器也可以放到 Linux 中，這就涉及到左右兩個不同的伺服器了。中間用一條豎線分隔一下。

客戶端可以呼叫伺服器，所以肯定要傳遞引數。假設你傳遞的是字串，沒有問題，所有的機器都可以識別正常的字串。

那麼現在假設你傳遞的引數是一個 Java 物件，比如叫 cat。伺服器並沒有那麼智慧，它並不會知道你傳遞的是一個 Java 物件，而不是其他型別的資料，它識別不了 Java 物件。

Java 物件本質上是 class 位元組碼，伺服器並不能根據這個位元組碼識別出該 Java 物件。所以，要提供一個公共的格式，不僅 Windows 能識別，你的伺服器也能識別的公共的格式。

我們將 Java 物件轉換成公共的格式叫做序列化，將公共的格式轉換成物件叫做反序列化。儲存到磁碟只是序列化的一種表現形式。

就這麼簡單，小小的問題，希望對大家有所幫助。

學習過程中遇到什麼問題或者想獲取學習資源的話，歡迎加入Java學習交流群346942462，我們一起學Java！

JAVA中序列化和反序列化中的靜態成員問題

關於這個標題的內容是面試筆試中比較常見的考題，大家跟隨我的部落格一起來學習下這個過程。

    JAVA中的序列化和反序列化主要用於： （1）將物件或者異常等寫入檔案，通過檔案互動傳輸資訊； （2）將物件或者異常等通過網路進行傳輸。     那麼為什麼需要序列化和反序列化呢？簡單來說，如果你只是自己同一臺機器的同一個環境下使用同一個JVM來操作，序列化和反序列化是沒必要的，當需要進行資料傳輸的時候就顯得十分必要。比如你的資料寫到檔案裡要被其他人的電腦的程式使用，或者你電腦上的資料需要通過網路傳輸給其他人的程式使用，像伺服器客戶端的這種模型就是一種應用，這個時候，大家想想，每個人的電腦配置可能不同，執行環境可能也不同，位元組序可能也不同，總之很多地方都不能保證一致，所以為了統一起見，我們傳輸的資料或者經過檔案儲存的資料需要經過序列化和編碼等操作，相當於互動雙方有一個公共的標準，按照這種標準來做，不管各自的環境是否有差異，各自都可以根據這種標準來翻譯出自己能理解的正確的資料。     在JAVA中有專門用於此類操作的API，供開發者直接使用，物件的序列化和反序列化可以通過將物件實現Serializable介面，然後用物件的輸入輸出流進行讀寫，下面看一個完整的例子。

1. package
    test2;  
2. import java.io.Serializable;  
3. publicclass DataObject implements Serializable {  
4.     /** 
5.      * 序列化的UID號 
6.      */
7.     privatestaticfinallong serialVersionUID = -3737338076212523007L;  
8.     publicstaticint i =  0;  
9.     private String word = "";  
10.     publicstaticvoid setI(int i){  
11.         DataObject.i = i;  
12.     }  
13.     publicvoid setWord(String word){  
14.         this.word = word;  
15.     }  
16.     publicstaticint getI() {  
17.         return i;  
18.     }  
19.     public String getWord() {  
20.         return word;  
21.     }  
22.     @Override
23.     public String toString() {  
24.         return"word = " + word + ", " + "i = " + i;  
25.     }  
26. }  

    上面這段程式是定義了要被序列化和反序列化的類DataObject，這個類實現了Serializable介面，裡面有幾點需要注意： （1）類中有一個靜態成員變數i，這個變數能不能被序列化呢？等下通過測試程式看一下； （2）類中重寫了toString方法，是為了列印結果。     接下來我們看一下測試該類的物件序列化和反序列化的一個測試程式版本，提前說明，這個版本是有問題的。

1. package test2;  
2. import java.io.File;  
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.FileOutputStream;  
6. import java.io.IOException;  
7. import java.io.ObjectInputStream;  
8. import java.io.ObjectOutputStream;  
9. /** 
10.  * Description: 測試物件的序列化和反序列 
11.  */
12. publicclass TestObjSerializeAndDeserialize {  
13.     publicstaticvoid main(String[] args) throws Exception {  
14.         // 序列化DataObject物件
15.         Serialize();  
16.         // 反序列DataObject物件
17.         DataObject object = Deserialize();  
18.         // 靜態成員屬於類級別的，所以不能序列化，序列化只是序列化了物件而已，
19.         // 這裡的不能序列化的意思，是序列化資訊中不包含這個靜態成員域，下面
20.         // 之所以i輸出還是2，是因為測試都在同一個機器（而且是同一個程序），因為這個jvm
21.         // 已經把i載入進來了，所以獲取的是載入好的i，如果是傳到另一臺機器或者關掉程式重新
22.         // 寫個程式讀入DataObject.txt，此時因為別的機器或新的程序是重新載入i的，所以i資訊就是初始時的資訊，即0
23.         System.out.println(object);  
24.     }  
25.     /** 
26.      * MethodName: SerializePerson  
27.      * Description: 序列化Person物件 
28.      * @author  
29.      * @throws FileNotFoundException 
30.      * @throws IOException 
31.      */
32.     privatestaticvoid Serialize() throws FileNotFoundException, IOException {  
33.         DataObject object = new DataObject();  
34.         object.setWord("123");  
35.         object.setI(2);  
36.         // 建立ObjectOutputStream物件輸出流，其中用到了檔案的描述符物件和檔案輸出流物件
37.         ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(  
38.                 new File("DataObject.txt")));  
39.         // 將DataObject物件儲存到DataObject.txt檔案中，完成對DataObject物件的序列化操作
40.         oo.writeObject(object);  
41.         System.out.println("Person物件序列化成功！");  
42.         // 最後一定記得關閉物件描述符！！！
43.         oo.close();  
44.     }  
45.     /** 
46.      * MethodName: DeserializePerson  
47.      * Description: 反序列DataObject物件 
48.      * @author  
49.      * @return 
50.      * @throws Exception 
51.      * @throws IOException 
52.      */
53.     privatestatic DataObject Deserialize() throws Exception, IOException {  
54.         // 建立ObjectInputStream物件輸入流，其中用到了檔案的描述符物件和檔案輸入流物件 
55.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(  
56.                 new File("DataObject.txt")));  
57.         // 從DataObject.txt檔案中讀取DataObject物件，完成對DataObject物件的反序列化操作
58.         DataObject object = (DataObject) ois.readObject();  
59.         System.out.println("Person物件反序列化成功！");  
60.         // 最後一定記得關閉物件描述符！！！
61.         ois.close();  
62.         return object;  
63.     }  
64. }  

    上面這段程式大家可以直接執行。注意，這裡定義了兩個方法Serialize()和Deserialize()，分別實現了序列化和反序列化的功能，裡面的主要用到了物件輸入輸出流和檔案輸入輸出流，大家看一下程式中的註釋就可以理解。在序列化的方法中，將物件的成員變數word設定成了"123"，i設定成了"2"，注意這裡的i是靜態變數，那麼以通常的序列化和反序列化的理解來看，無非就是一個正過程和一個逆過程，最終經過反序列化後，輸出物件中的word和i時，大家一般都覺得應該還是"123"和"2"，那麼上面程式的執行結果確實就是：

1. word = "123", i = 2

          這樣會使得大家覺得理應就是如此，其實這是錯誤的。大家要記住：      靜態成員屬於類級別的，所以不能序列化，序列化只是序列化了物件而已，這裡“不能序列化”的意思是序列化資訊中不包含這個靜態成員域，下面之所以i輸出還是2，是因為測試都在同一個機器（而且是同一個程序），因為這個jvm已經把i載入進來了，所以獲取的是載入好的i，如果是傳到另一臺機器或者關掉程式重新寫個程式讀入DataObject.txt，此時因為別的機器或新的程序是重新載入i的，所以i資訊就是初始時的資訊，即0。所以，總結來看，靜態成員是不能被序列化的，靜態成員定以後的預設初始值是0，所以正確的執行結果應該是：

1. word = "123", i = 0

    那麼既然如此，怎樣才能測試出正確的結果呢？大家注意，上面的程式是直接在一個JVM一個程序中操作完了序列化和反序列化的所有過程，故而JVM中已經儲存了i = 2，所以i的值沒有變化，所以再次讀出來肯定還是2。如果想得出正確的結果，必須在兩個JVM中去測試，但是大家的電腦很難做到這種測試環境，所以可以通過以下方法來測試。

1. package test2;  
2. import java.io.File;  
3. import java.io.FileNotFoundException;  
4. import java.io.FileOutputStream;  
5. import java.io.IOException;  
6. import java.io.ObjectOutputStream;  
7. /** 
8.  * Description: 測試物件的序列化 
9.  */
10. publicclass SerializeDataobject {  
11.     publicstaticvoid main(String[] args) throws Exception {  
12.         // 序列化DataObject物件
13.         Serialize();  
14.     }  
15.     /** 
16.      * MethodName: SerializePerson  
17.      * Description: 序列化Person物件 
18.      * @author  
19.      * @throws FileNotFoundException 
20.      * @throws IOException 
21.      */
22.     privatestaticvoid Serialize() throws FileNotFoundException, IOException {  
23.         DataObject object = new DataObject();  
24.         object.setWord("123");  
25.         object.setI(2);  
26.         // 建立ObjectOutputStream物件輸出流，其中用到了檔案的描述符物件和檔案輸出流物件
27.         ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(  
28.                 new File("DataObject.txt")));  
29.         // 將DataObject物件儲存到DataObject.txt檔案中，完成對DataObject物件的序列化操作
30.         oo.writeObject(object);  
31.         System.out.println("Person物件序列化成功！");  
32.         // 最後一定記得關閉物件描述符！！！
33.         oo.close();  
34.     }  
35. }  

    上面這個類只用來進行序列化，物件被序列化後儲存在檔案"DataObject.txt"中，然後程式執行結束，JVM退出。接下來看另一段程式。

1. package test2;  
2. import java.io.File;  
3. import java.io.FileInputStream;  
4. import java.io.IOException;  
5. import java.io.ObjectInputStream;  
6. /** 
7.  * Description: 測試物件的反序列 
8.  */
9. publicclass DeserializeDataobject {  
10.     publicstaticvoid main(String[] args) throws Exception {  
11.         // 反序列DataObject物件
12.         DataObject object = Deserialize();  
13.         // 靜態成員屬於類級別的，所以不能序列化，序列化只是序列化了物件而已，
14.         // 這裡的不能序列化的意思，是序列化資訊中不包含這個靜態成員域，下面
15.         // 之所以i輸出還是2，是因為測試都在同一個機器（而且是同一個程序），因為這個jvm
16.         // 已經把i載入進來了，所以獲取的是載入好的i，如果是傳到另一臺機器或者關掉程式重新
17.         // 寫個程式讀入DataObject.txt，此時因為別的機器或新的程序是重新載入i的，所以i資訊就是初始時的資訊，即0
18.         System.out.println(object);  
19.     }  
20.     /** 
21.      * MethodName: DeserializePerson  
22.      * Description: 反序列DataObject物件 
23.      * @author  
24.      * @return 
25.      * @throws Exception 
26.      * @throws IOException 
27.      */
28.     privatestatic DataObject Deserialize() throws Exception, IOException {  
29.         // 建立ObjectInputStream物件輸入流，其中用到了檔案的描述符物件和檔案輸入流物件 
30.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(  
31.                 new File("DataObject.txt")));  
32.         // 從DataObject.txt檔案中讀取DataObject物件，完成對DataObject物件的反序列化操作
33.         DataObject object = (DataObject) ois.readObject();  
34.         System.out.println("Person物件反序列化成功！");  
35.         // 最後一定記得關閉物件描述符！！！
36.         ois.close();  
37.         return object;  
38.     }  
39. }  

    上面這段程式用來實現物件的反序列化，它從檔案"DataObject.txt"中讀出物件的相關資訊，然後進行了反序列化，最終輸出物件中word和i的值，這個程式輸出的結果才是word = "123", i = 0 這個才是正確的結果，這是因為序列化和反序列化都有自己的main方法，先序列化，然後JVM退出，再次執行反序列化，JVM重新載入DataObject類，此時i = 0，"DataObject.txt"檔案中其實是沒有i的資訊的，只有word的資訊。這裡通過先後執行序列化和反序列化，讓JVM得到一次重新載入類的機會，模擬了兩個JVM下執行的結果。     總之，大家要記住以下幾點： （1）序列化和反序列化的實現方法和應用場合； （2）靜態成員是不能被序列化的，因為靜態成員是隨著類的載入而載入的，與類共存亡，並且靜態成員的預設初始值都是0； （3）要明白錯誤的那個測試程式的原因，搞明白JVM的一些基本機制； （4）要想直接通過列印物件而輸出物件的一些屬性資訊，要重寫toString方法。    上面只是我的一些個人總結，歡迎大家指正和補充。