副标题#e#
当一个父类实现Serializable接口后，他的子类都将自动的实现序列化。
以下验证了这一点：
package Serial;
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. ”
#p#副标题#e#
也就是说，要为一个没有实现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接口的父类，编写一个可以或许序列化的子类 子类将自动的实现序列化
#p#分页标题#e#
为一个没有实现Serializable接口的父类，编写一个可以或许序列化的子类 1，父类要有一个无参的constructor；2，子类要先序列化自身，然后子类要认真序列化父类的域。
