序列化中的继承问题

package tigers;

import java.io.*;

public class Tiger3 {
static class Sub extends Super {
private String name;
public Sub(int id, int uid, String name) {
super(id, uid);
this.name = name;
}
public String toString() {
return "Tiger3$Sub:(" + super.toString() + "," + name + ")";
}

private void writeObject(ObjectOutputStream oos) throws IOException {
System.out.println("Sub.writeObject()");
oos.defaultWriteObject();
}
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
System.out.println("Sub.readObject()");
ois.defaultReadObject();
}
}
static class Super implements Serializable {
private int id;
private transient int uid;
public Super(int id, int uid) {
this.id = id;
this.uid = uid;
}
private static final long serialVersionUID = 1L;
private void writeObject(ObjectOutputStream oos) throws IOException {
System.out.println("Super.writeObject()");
oos.defaultWriteObject();
oos.writeInt(uid);
}
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
System.out.println("Super.readObject()");
ois.defaultReadObject();
uid = ois.readInt();
}
public String toString() {
return "Tiger3$Super:(" + id + "," + uid + ")";
}
}
public static void main(String[] args) {
Tiger3.Super sup = new Tiger3.Super(55, 1000);
Tiger3.Sub sub = new Tiger3.Sub(12, 100, "sub");
try {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Tiger3$Super.tmp"));
oos.writeObject(sup);
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Tiger3$Super.tmp"));
sup = (Tiger3.Super) ois.readObject();
System.out.println(sup);
oos = new ObjectOutputStream(new FileOutputStream("Tiger3$Sub.tmp"));
oos.writeObject(sub);
ois = new ObjectInputStream(new FileInputStream("Tiger3$Sub.tmp"));
sub = (Tiger3.Sub) ois.readObject();
System.out.println(sub);
} catch (IOException ioe) {

} catch (ClassNotFoundException cnfe) {

}
}
}

结果：

Super.writerObject()
Super.readObject()
Tiger3$Super:(55,1000)
Super.writerObject()
Sub.writeObject()
Super.readObject()
Sub.readObject()
Tiger3$Sub:(Tiger3$Super:(12,100),sub)

如果将Super和Sub中writeObject()和readObject()的修饰符改成public:

Tiger3$Super:(55,0)
Tiger3$Sub:(Tiger3$Super:(12,0),sub)

Tiger3$Super:(55,0)
Tiger3$Sub:(Tiger3$Super:(12,0),sub)

结论：

一、如果Super类包含需要序列化的primitive类型变量，应该实现writeObject()和readObject()方法，并在里面分别调用ObjectOutputStream.defaultWriteObject()和ObjectInputStream.defaultReadObject()方法。

二、writeObject()和readObject()的修饰符、返回类型、参数必须符合规定，即必须是如下格式：

private void writeObject(ObjectOutputStream o) throws...;

private void readObject(ObjectInputStream o) throws...;

否则这两个方法将不会被调用。

三、如果父类实现了Serializable接口，子类将自动得到可序列化特性。并且序列化子类时，父类的writeObject()和readObject()将得到调用。换言之，在序列化子类之前，父类将会自动被序列化。

/*
* Created on 2005-2-7
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package tigers;

import java.io.*;

/**
* @author bitan
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class Tiger4 {
static class Super {
private String name;
public Super(String name) {
this.name = name;
}
public String toString() {
return "Tiger4$Super:(" + name + ")";
}
}
static class Sub extends Super implements Serializable {
private String name;
Sub (String superName, String name) {
super(superName);
this.name = name;
}
public String toString() {
return "Tiger4$Sub:("+ super.toString() + "," + name + ")";
}
}
public static void main(String[] args) {
Sub sub = new Sub("super","sub");
try {
System.out.println("序列化之前：" + sub);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Tiger4$Sub.tmp"));
oos.writeObject(sub);
System.out.println("序列化之后：" + sub);
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Tiger4$Sub.tmp"));
sub = (Sub) ois.readObject();
System.out.println("反序列化之后：" + sub);
} catch (IOException ioe) {
ioe.printStackTrace();
} catch (ClassNotFoundException cnfe) {
cnfe.printStackTrace();
}
}
}

结果：

序列化之前：Tiger4$Sub:(Tiger4$Super:(super),sub)
序列化之后：Tiger4$Sub:(Tiger4$Super:(super),sub)

java.io.InvalidClassException: tigers.Tiger4$Sub; no valid constructor
at java.io.ObjectStreamClass.<init>(ObjectStreamClass.java:428)
at java.io.ObjectStreamClass.lookup(ObjectStreamClass.java:268)
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1029)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:291)
at tigers.Tiger4.main(Tiger4.java:41)

给Super加上无参数构造函数

public Super() {

this.name = "default";

}

后：

序列化之前：Tiger4$Sub:(Tiger4$Super:(super),sub)
序列化之后：Tiger4$Sub:(Tiger4$Super:(super),sub)
反序列化之后：Tiger4$Sub:(Tiger4$Super:(default),sub)

现在，给Super的name字段加上Setter和Getter方法：

public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}

并且给Sub加上writeObject()和readObject()方法：

private void writeObject(ObjectOutputStream oos) throws IOException {
oos.defaultWriteObject();
oos.writeObject(super.getName());
}
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ois.defaultReadObject();
super.setName((String) ois.readObject());
}

结果：

序列化之前：Tiger4$Sub:(Tiger4$Super:(super),sub)
序列化之后：Tiger4$Sub:(Tiger4$Super:(super),sub)
反序列化之后：Tiger4$Sub:(Tiger4$Super:(super),sub)

结论：

一、当父类没有实现Serializable接口的前提下，序列化子类时父类将不会被自动序列化。而反序列化子类时，父类的无参数构造方法将会被调用。

二、如果想在序列化子类的同时也自动序列化父类中的字段，必须在子类的writeObject()和readObject()中相应实现。