Serializable接口

序列化接口，
web传输时使用，
只需要声明，没有要实现的方法。
运行时自动串行化zable接口

java很厉害的一个地方，比如你要传输一个对象给对方，但是你不可能将对象传输过去，所以你就要将对象序列化，将它转换为流的形式，然后通过管道传输过去，而接受的一方则用jvm将其再转换为对象

保存对象的所有信息.(所有的对象都必须实现Serializable)

 

Serializable接口初探

java 2009-08-15 23:50:52 阅读48 评论0   字号：大中小 订阅

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

　　Java的"对象序列化"能让你将一个实现了Serializable接口的对象转换成一组byte，这样日后要用这个对象时候，你就能把这些byte数据恢复出来，并据此重新构建那个对象了。

　　要想序列化对象，你必须先创建一个OutputStream，然后把它嵌进ObjectOutputStream。这时，你就能用writeObject( )方法把对象写入OutputStream了。

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

　　读的时候，你得把InputStream嵌到 ObjectInputStream里面，然后再调用readObject( )方法。不过这样读出来的，只是一个Object的reference，因此在用之前，还得先下传。readObject 方法负责从流中读取并还原类字段。它可以调用 in.defaultReadObject 来调用默认机制，以还原对象的非静态和非瞬态字段。

　　　defaultReadObject 方法使用流中的信息来分配流中通过当前对象中相应命名字段保存的对象的字段。这用于处理类发展后需要添加新字段的情形。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。看一个列子：
　　最后结果如下：
node 0
node 1
node 2
node 3
node 4
node 5
node 6

1. import java.io.*;
   
2. 
   
3. class tree implements java.io.Serializable {
   
4.     public tree left;
   
5. 
   
6.     public tree right;
   
7. 
   
8.     public int id;
   
9. 
   
10.     public int level;
    
11. 
    
12.     private static int count = 0;
    
13. 
    
14.     public tree(int depth) {
    
15.         id = count++;
    
16.         level = depth;
    
17.         if (depth > 0) {
    
18.             left = new tree(depth - 1);
    
19.             right = new tree(depth - 1);
    
20.         }
    
21.     }
    
22. 
    
23.     public void print(int levels) {
    
24.         for (int i = 0; i < level; i++)
    
25.             System.out.print("    ");
    
26.         System.out.println(" node  " + id);
    
27. 
    
28.         if (level <= levels && left != null)
    
29.             left.print(levels);
    
30. 
    
31.         if (level <= levels && right != null)
    
32.             right.print(levels);
    
33.     }
    
34. 
    
35.     public static void main(String argv[]) {
    
36.         try {
    
37.             /** *//** *//** *//**//* 创建一个文件写入序列化树。 */
    
38.             FileOutputStream ostream = new FileOutputStream(" tree.tmp ");
    
39.             /** *//** *//** *//**//* 创建输出流 */
    
40.             ObjectOutputStream p = new ObjectOutputStream(ostream);
    
41. 
    
42.             /** *//** *//** *//**//* 创建一个二层的树。 */
    
43.             tree base = new tree(2);
    
44.             p.writeObject(base); // 将树写入流中。
    
45.             p.writeObject(" LiLy is 惠止南国 ");
    
46.             p.flush();
    
47.             ostream.close(); // 关闭文件。
    
48.             /** *//** *//** *//**//* 打开文件并设置成从中读取对象。 */
    
49.             FileInputStream istream = new FileInputStream(" tree.tmp ");
    
50.             ObjectInputStream q = new ObjectInputStream(istream);
    
51. 
    
52.             /** *//** *//** *//**//* 读取树对象，以及所有子树 */
    
53.             tree new_tree = (tree) q.readObject();
    
54.             new_tree.print(2); // 打印出树形结构的最上面 ２级
    
55.             String name = (String) q.readObject();
    
56.             System.out.println("   " + name);
    
57.         } catch (Exception ex) {
    
58.             ex.printStackTrace();
    
59.         }
    
60.     }
    
61. }

复制代码

可以看到，在序列化的时候，writeObject与readObject之间的先后顺序。readObject将最先write的object read出来。用数据结构的术语来讲就姑且称之为先进先出吧！

　　在序列化时，有几点要注意的：
　　１：当一个对象被序列化时，只保存对象的非静态成员变量，不能保存任何的成员方法和静态的成员变量。
        ２：如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存。
　　３：如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化操作将会失败，并且会抛出一个NotSerializableException。我们可以将这个引用标记为transient，那么对象仍然可以序列化

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

1. private   void  readObject(java.io.ObjectInputStream stream)
   
2.       throws  IOException, ClassNotFoundException;
   
3. private   void  writeObject(java.io.ObjectOutputStream stream)
   
4.       throws  IOException

复制代码

这二个方法！
　　示例：

1. import java.io.*;
   
2. 
   
3. class ObjectSerialTest {
   
4.     public static void main(String[] args) throws Exception {
   
5.         Employee e1 = new Employee(" zhangsan ", 25, 3000.50);
   
6.         Employee e2 = new Employee(" lisi ", 24, 3200.40);
   
7.         Employee e3 = new Employee(" wangwu ", 27, 3800.55);
   
8. 
   
9.         FileOutputStream fos = new FileOutputStream(" employee.txt ");
   
10.         ObjectOutputStream oos = new ObjectOutputStream(fos);
    
11.         oos.writeObject(e1);
    
12.         oos.writeObject(e2);
    
13.         oos.writeObject(e3);
    
14.         oos.close();
    
15.         FileInputStream fis = new FileInputStream(" employee.txt ");
    
16.         ObjectInputStream ois = new ObjectInputStream(fis);
    
17.         Employee e;
    
18.         for (int i = 0; i < 3; i++) {
    
19.             e = (Employee) ois.readObject();
    
20.             System.out.println(e.name + " : " + e.age + " : " + e.salary);
    
21.         }
    
22.     }
    
23. }
    
24. 
    
25. class Employee implements Serializable {
    
26.     String name;
    
27. 
    
28.     int age;
    
29. 
    
30.     double salary;
    
31. 
    
32.     transient Thread t = new Thread();
    
33. 
    
34.     public Employee(String name, int age, double salary) {
    
35.         this.name = name;
    
36.         this.age = age;
    
37.         this.salary = salary;
    
38.     }
    
39. 
    
40.     private void writeObject(java.io.ObjectOutputStream oos) throws IOException {
    
41.         oos.writeInt(age);
    
42.         oos.writeUTF(name);
    
43.         System.out.println(" Write Object ");
    
44.     }
    
45. 
    
46.     private void readObject(java.io.ObjectInputStream ois) throws IOException {
    
47.         age = ois.readInt();
    
48.         name = ois.readUTF();
    
49.         System.out.println(" Read Object ");
    
50.     }
    
51. }