浅谈Java中的序列化之当序列化遇上继承关系

父类实现了Serializable，子类不需要实现Serializable

相关注意事项：
    a）序列化时，只对对象的状态进行保存，而不管对象的方法；
    b）当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口；
    c）当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；
    d）并非所有的对象都可以序列化，至于为什么不可以，有很多原因了,比如：
        1，安全方面的原因，比如一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件，或者进行rmi传输等等，在序列化进行传输的过程中，这个对象的private等域是不受保护的。
        2，资源分配方面的原因，比如socket，thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分配，而且，也是没有必要这样实现。

例子：

 1，父类实现了Serializable，子类没有，父类有int a = 1；int b = 2；int c = 3，子类有int d = 4；int e = 5

序列化子类的时候，d和e会不会被序列化？（答案：会）

2，反过来父类未实现Serializable，子类实现了，序列化子类实例的时候，父类的属性是直接被跳过不保存，还是能保存但不能还原？（答案：值不保存）

小结：父类实现接口后，所有派生类的属性都会被序列化。子类实现接口的话，父类的属性值丢失。

---

 

Java中序列化之子类继承父类序列化

当一个父类实现Serializable接口后，他的子类都将自动的实现序列化。 
以下验证了这一点： 

import java.io.Serializable; 
public class SuperC implements Serializable {// 父类实现了序列化 
　int supervalue; 
　public SuperC(int supervalue) { 
　　this.supervalue = supervalue; 
　} 
　public String toString() { 
　　return "supervalue: "+supervalue; 
　} 
} 

public class SubC extends SuperC {// 子类 
　int subvalue; 

　public SubC(int supervalue,int subvalue) { 
　　super(supervalue); 
　　this.subvalue=subvalue; 
　} 

　public String toString() { 
　　return super.toString()+" sub: "+subvalue; 
　} 
} 

public class Test1 { 
　public static void main(String [] args){ 
　　SubC subc=new SubC(100,200); 
　　FileInputStream in=null; 
　　FileOutputStream out=null; 
　　ObjectInputStream oin=null; 
　　ObjectOutputStream oout=null; 
　　try { 
　　　out = new FileOutputStream("Test1.txt");// 子类序列化 
　　　oout = new ObjectOutputStream(out); 
　　　oout.writeObject(subc); 
　　　oout.close(); 
　　　oout=null; 

　　　in = new FileInputStream("Test1.txt"); 
　　　oin = new ObjectInputStream(in); 
　　　SubC subc2=(SubC)oin.readObject();// 子类反序列化 
　　　System.out.println(subc2); 
　　} catch (Exception ex){ 
　　　ex.printStackTrace(); 
　　} finally{ 
　　// 此处省略... 
　} 
}  

运行结果： supervalue： 100； sub： 200 

可见子类成功的序列化/反序列化了

---

　　尽管让子类实现序列化看起来是一件很简单的事情，但有的时候，往往我们不能够让父类实现Serializable接口，原因是有时候父类是抽象的（这并没有关系），并且父类不能够强制每个子类都拥有序列化的能力。换句话说父类设计的目的仅仅是为了被继承。 

要为一个没有实现Serializable接口的父类，编写一个能够序列化的子类是一件很麻烦的事情。java docs中提到： 

“To allow subtypes of non-serializable classes to be serialized, the subtype may assume responsibility for saving and restoring the state of the supertype's public, protected, and (if accessible) package fields. The subtype may assume this responsibility only if the class it extends has an accessible no-arg constructor to initialize the class's state. It is an error to declare a class Serializable if this is not the case. The error will be detected at runtime. ” 

也就是说，要为一个没有实现Serializable接口的父类，编写一个能够序列化的子类要做两件事情： 

• 其一、父类要有一个无参的constructor
• 其二、子类要负责序列化（反序列化）父类的域  

---

验证上面的说法：

我们将上面的父类SuperC的Serializable接口去掉，而给子类SubC加上Serializable接口。运行后产生错误： 

java.lang.Error: Unresolved compilation problem: 
Serializable cannot be resolved or is not a valid superinterface 
at Serial.SubC.<init>(SubC.java:15) 
at Serial.Test1.main(Test1.java:19) 
Exception in thread "main" 

果真如docs中所说的一样，父类缺少无参构造函数是不行的。

接下来，按照docs中的建议我们改写这个例子：

public abstract class SuperC { 
　int supervalue; 
　public SuperC(int supervalue) { 
　　this.supervalue = supervalue; 
　}
　public SuperC(){}// 增加一个无参的constructor 
　　public String toString() { 
　　　return "supervalue: "+supervalue; 
　　} 
　} 

　public class SubC extends SuperC implements Serializable { 
　　int subvalue; 

　　public SubC(int supervalue,int subvalue) { 
　　　super(supervalue); 
　　　this.subvalue=subvalue; 
　　} 

　　public String toString() { 
　　　return super.toString()+" sub: "+subvalue; 
　　} 

　　private void writeObject(java.io.ObjectOutputStream out) 
　　throws IOException{ 
　　　out.defaultWriteObject();// 先序列化对象 
　　　out.writeInt(supervalue);// 再序列化父类的域 
　　} 
　　private void readObject(java.io.ObjectInputStream in) 
　　throws IOException, ClassNotFoundException{ 
　　　in.defaultReadObject();// 先反序列化对象 
　　　supervalue=in.readInt();// 再反序列化父类的域 
　　} 
}

　　运行结果证明了这种方法是正确的。在此处我们用到了writeObject/ readObject方法，这对方法如果存在的话，序列化时就会被调用，以代替默认的行为（以后还要探讨，先了解这么多）。我们在序列化时，首先调用了ObjectOutputStream的defaultWriteObject，它使用默认的序列化行为，然后序列化父类的域；反序列化的时候也一样。 

---

 

归纳： 

• 为一个实现Serializable接口的父类，编写一个能够序列化的子类，子类将自动的实现序列化 
• 为一个没有实现Serializable接口的父类，编写一个能够序列化的子类，则需要：1，父类要有一个无参的constructor；2， 子类要先序列化自身，然后子类要负责序列化父类的域 

---

来源于：

http://www.yesky.com/376/1908876.shtml