java 序列化Serializable

序列化机制只保存对象的类型信息，属性的类型信息和属性值，和方法没有什么关系，你就是给这个类增加10000个方法，序列化内容也不会增加任何东西

  简单来说序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化，流的概念这里不用多说(就是I/O)，我们可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间(注：要想将对象传输于网络必须进行流化)！在对对象流进行读写操作时会引发一些问题，而序列化机制正是用来解决这些问题的！

问题的引出：

如上所述，读写对象会有什么问题呢？比如：我要将对象写入一个磁盘文件而后再将其读出来会有什么问题吗？别急，其中一个最大的问题就是对象引用！举个例子来说：假如我有两个类，分别是A和B，B类中含有一个指向A类对象的引用，现在我们对两个类进行实例化{ A a = new A(); B b = new B(); }，这时在内存中实际上分配了两个空间，一个存储对象a，一个存储对象b，接下来我们想将它们写入到磁盘的一个文件中去，就在写入文件时出现了问题！因为对象b包含对对象a的引用，所以系统会自动的将a的数据复制一份到b中，这样的话当我们从文件中恢复对象时(也就是重新加载到内存中)时，内存分配了三个空间，而对象a同时在内存中存在两份，想一想后果吧，如果我想修改对象a的数据的话，那不是还要搜索它的每一份拷贝来达到对象数据的一致性，这不是我们所希望的！

以下序列化机制的解决方案：

1.保存到磁盘的所有对象都获得一个序列号(1, 2, 3等等)

2.当要保存一个对象时，先检查该对象是否被保存了。

3.如果以前保存过，只需写入"与已经保存的具有序列号x的对象相同"的标记，否则，保存该对象

通过以上的步骤序列化机制解决了对象引用的问题！

序列化的实现

将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

例子：

 

Java代码  

1. import java.io.*;  
2.   
3. public class Test {  
4.         public static void main(String[] args) {  
5.                 Employee harry = new Employee("Harry Hacker", 50000);  
6.                 Manager manager1 = new Manager("Tony Tester", 80000);  
7.                 manager1.setSecretary(harry);  
8.                 Employee[] staff = new Employee[2];  
9.                 staff[0] = harry;  
10.                 staff[1] = manager1;  
11.                 try {  
12.                         ObjectOutputStream out = new ObjectOutputStream(  
13.                                         new FileOutputStream("employee.dat"));  
14.                         out.writeObject(staff);  
15.                         out.close();  
16.                         ObjectInputStream in = new ObjectInputStream(new FileInputStream(  
17.                                         "employee.dat"));  
18.                         Employee[] newStaff = (Employee[]) in.readObject();  
19.                         in.close();  
20.   
21.                         /** 
22.                          * 通过harry对象来加薪 将在secretary上反映出来 
23.                          */  
24.                         newStaff[0].raiseSalary(10);  
25.                         for (int i = 0; i < newStaff.length; i++)  
26.                                 System.out.println(newStaff[i]);  
27.                 } catch (Exception e) {  
28.                         e.printStackTrace();  
29.   
30.                 }  
31.         }  
32. }  
33.   
34. class Employee implements Serializable {  
35.         public Employee(String n, double s) {  
36.                 name = n;  
37.                 salary = s;  
38.         }  
39.         /** 
40.          *  
41.          * 加薪水 
42.          *  
43.          */  
44.         public void raiseSalary(double byPercent) {  
45.                 double raise = salary * byPercent / 100;  
46.                 salary += raise;  
47.         }  
48.   
49.         public String toString() {  
50.                 return getClass().getName() + "[name = " + name+ ",salary = " + salary+ "]";  
51.         }  
52.         private String name;  
53.         private double salary;  
54. }  
55.   
56. class Manager extends Employee  
57.   
58. {  
59.         public Manager(String n, double s)  
60.         {  
61.                 super(n, s);  
62.                 secretary = null;  
63.         }  
64.         /** 
65.          *  
66.          * 设置秘书 
67.          *  
68.          */  
69.         public void setSecretary(Employee s)  
70.         {  
71.            secretary = s;  
72.         }  
73.           
74.         public String toString()  
75.         {  
76.                 return super.toString()+ "[secretary = " + secretary+ "]";  
77.         }  
78.   
79.         // secretary代表秘书  
80.   
81.         private Employee secretary;  
82.   
83. }  

 

修改默认的序列化机制 

在序列化的过程中，有些数据字段我们不想将其序列化，对于此类字段我们只需要在定义时给它加上transient关键字即可，对于transient字段序列化机制会跳过不会将其写入文件，当然也不可被恢复。但有时我们想将某一字段序列化，但它在SDK中的定义却是不可序列化的类型，这样的话我们也必须把他标注为transient，可是不能写入又怎么恢复呢？好在序列化机制为包含这种特殊问题的类提供了如下的方法定义：

Java代码  

1. private void readObject(ObjectInputStream in) throws   
2.   
3. IOException, ClassNotFoundException;  
4.   
5. private void writeObject(ObjectOutputStream out) throws  
6.   
7. IOException;  

 (注：这些方法定义时必须是私有的，因为不需要你显示调用，序列化机制会自动调用的)

使用以上方法我们可以手动对那些你又想序列化又不可以被序列化的数据字段进行写出和读入操作。

下面是一个典型的例子，java.awt.geom包中的Point2D.Double类就是不可序列化的，因为该类没有实现Serializable接口，在我的例子中将把它当作LabeledPoint类中的一个数据字段，并演示如何将其序列化！

Java代码  

1. import java.io.*;  
2.   
3. import java.awt.geom.*;  
4.   
5. public class TransientTest  
6.   
7. {  
8.   
9.         public static void main(String[] args)  
10.         {  
11.                 LabeledPoint label = new LabeledPoint("Book", 5.00, 5.00);  
12.                 try  
13.                 {  
14.                         System.out.println(label);// 写入前  
15.                         ObjectOutputStream out = new ObjectOutputStream(new  
16.                         FileOutputStream("Label.txt"));  
17.                         out.writeObject(label);  
18.                         out.close();  
19.                         System.out.println(label);// 写入后  
20.                         ObjectInputStream in = new ObjectInputStream(new  
21.                         FileInputStream("Label.txt"));  
22.                         LabeledPoint label1 = (LabeledPoint) in.readObject();  
23.                         in.close();  
24.                         System.out.println(label1);// 读出并加1.0后  
25.                 }  
26.                 catch (Exception e)  
27.                 {  
28.                         e.printStackTrace();  
29.                 }  
30.         }  
31. }  
32.   
33. class LabeledPoint implements Serializable  
34. {  
35.         public LabeledPoint(String str, double x, double y)  
36.         {  
37.                 label = str;  
38.                 point = new Point2D.Double(x, y);  
39.         }  
40.   
41.         private void writeObject(ObjectOutputStream out) throws IOException  
42.         {  
43.                 /** 
44.                  *  
45.                  * 必须通过调用defaultWriteObject()方法来写入 
46.                  *  
47.                  * 对象的描述以及那些可以被序列化的字段 
48.                  *  
49.                  */  
50.   
51.                 out.defaultWriteObject();  
52.                 out.writeDouble(point.getX());  
53.                 out.writeDouble(point.getY());  
54.         }  
55.   
56.         private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException  
57.         {  
58.                 /** 
59.                  *  
60.                  * 必须调用defaultReadObject()方法 
61.                  *  
62.                  */  
63.                 in.defaultReadObject();  
64.                 double x = in.readDouble() + 1.0;  
65.                 double y = in.readDouble() + 1.0;  
66.                 point = new Point2D.Double(x, y);  
67.   
68.         }  
69.   
70.         public String toString()  
71.         {  
72.                 return getClass().getName()+ "[label = " + label+ ", point.getX() = " + point.getX()+ ", point.getY() = " + point.getY()+ "]";  
73.         }  
74.         private String label;  
75.         transient private Point2D.Double point;  
76. }