文檔：
http://www.runoob.com/java/java-serialization.html
http://www.importnew.com/24490.html
https://www.cnblogs.com/wxgblogs/p/5849951.html

概述：
Java 提供了一種對象序列化的機制，該機制中，一個對象可以被表示為一個字節序列，該字節序列包括該對象的數據、有關對象的類型的信息和存儲在對象中數據的類型；
將序列化對象寫入文件之後，可以從文件中讀取出來，並且對它進行反序列化，也就是說，對象的類型信息、對象的數據，還有對象中的數據類型可以用來在內存中新建對象；
整個過程都是 Java 虛擬機（JVM）獨立的，也就是說，在一個平臺上序列化的對象可以在另一個完全不同的平臺上反序列化該對象；

一個類的對象要想序列化成功，必須滿足兩個條件：
該類必須實現 java.io.Serializable 對象；
該類的所有屬性必須是可序列化的；如果有一個屬性不是可序列化的，則該屬性必須註明是短暫的；
註意：如果你想知道一個 Java 標準類是否是可序列化的，請查看該類的文檔；檢驗一個類的實例是否能序列化十分簡單， 只需要查看該類有沒有實現 java.io.Serializable接口；

 1 /**
 2  * 實現了 java.io.Serializable 接口的類
 3  */
 4 package serialize;
 5 
 6 public class Employee implements java.io.Serializable
 7 {
 8     private static final long serialVersionUID = 1L;
 9     
10     private String name;
11     private String address;
12     private transient int SSN;
13     private
 
 int number;
14     
15     public void mailCheck()
16     {
17        System.out.println("Mailing a check to " + name + " " + address);
18     }
19 
20     public String getName()
21     {
22         return name;
23     }
24     public void setName(String name)
25     {
26         this.name = name;
27     }
28     public String getAddress()
29     {
30         return address;
31     }
32     public void setAddress(String address)
33     {
34         this.address = address;
35     }
36     public int getSSN()
37     {
38         return SSN;
39     }
40     public void setSSN(int sSN)
41     {
42         SSN = sSN;
43     }
44     public int getNumber()
45     {
46         return number;
47     }
48     public void setNumber(int number)
49     {
50         this.number = number;
51     }
52 }

 1 /**
 2  * ObjectOutputStream 類的使用：序列化一個對象
 3  */
 4 package serialize;
 5 
 6 import java.io.FileOutputStream;
 7 import java.io.IOException;
 8 import java.io.ObjectOutputStream;
 9 
10 public class SerializeTest01
11 {
12     public static void main(String[] args)
13     {
14         Employee employee = new Employee();
15         employee.setAddress("地址");
16         employee.setName("姓名");
17         employee.setNumber(01);
18         employee.setSSN(0001);
19         
20         FileOutputStream fileOut = null;
21         ObjectOutputStream out = null;
22         try
23         {
24             fileOut = new FileOutputStream("F://test//employee.ser");
25             out = new ObjectOutputStream(fileOut);
26             out.writeObject(employee);
27             System.out.printf("Serialized data is saved in F:/test/employee.ser");
28         }
29         catch(IOException i)
30         {
31             i.printStackTrace();
32         }
33         finally
34         {
35             if(null != out)
36             {
37                 try
38                 {
39                     out.close();
40                 } 
41                 catch (IOException e)
42                 {
43                     e.printStackTrace();
44                 }
45             }
46             
47             if(null != fileOut)
48             {
49                 try
50                 {
51                     fileOut.close();
52                 } 
53                 catch (IOException e)
54                 {
55                     e.printStackTrace();
56                 }
57             }
58             
59         }
60         
61     }
62 }

 1 /**
 2  * ObjectInputStream 類的使用：反序列化生成對象
 3  */
 4 package serialize;
 5 
 6 import java.io.FileInputStream;
 7 import java.io.IOException;
 8 import java.io.ObjectInputStream;
 9 
10 public class SerializeTest02
11 {
12     public static void main(String[] args)
13     {
14         Employee e = null;
15         
16         FileInputStream fileIn = null;
17         ObjectInputStream in = null;
18         
19         try
20         {
21             fileIn = new FileInputStream("F://test//employee.ser");
22             in = new ObjectInputStream(fileIn);
23             e = (Employee) in.readObject();
24         }
25         catch(IOException i)
26         {
27             i.printStackTrace();
28             return;
29         }
30         catch(ClassNotFoundException c)
31         {
32             System.out.println("Employee class not found");
33             c.printStackTrace();
34             return;
35         }
36         finally
37         {
38             if(null != fileIn)
39             {
40                 try
41                 {
42                     fileIn.close();
43                 } 
44                 catch (IOException e1)
45                 {
46                     e1.printStackTrace();
47                 }
48             }
49             if(null != in)
50             {
51                 try
52                 {
53                     in.close();
54                 } 
55                 catch (IOException e1)
56                 {
57                     e1.printStackTrace();
58                 }
59             }
60         }
61         
62         System.out.println("Deserialized Employee...");
63         System.out.println("Name: " + e.getName());
64         System.out.println("Address: " + e.getAddress());
65         // 註意：當對象被序列化時，屬性 SSN 的值為 0001，但是因為該屬性是短暫的，該值沒有被發送到輸出流；
66         // 所以反序列化後 Employee 對象的 SSN 屬性為 0
67         System.out.println("SSN: " + e.getSSN());
68         System.out.println("Number: " + e.getNumber());
69         
70         e.mailCheck();
71     }
72 }

Java - 序列化(1)