运行的结果如下：

Worm constructor:6
Worm constructor:5
Worm constructor:4
Worm constructor:3
Worm constructor:2
Worm constructor:1
序列化操纵之前
w=:a(853):b(119):c(802):d(788):e(199):f(881)
反序列化操作1之后
Worm storage By FileOutputStream
w1::a(853):b(119):c(802):d(788):e(199):f(881)
反序列化操作2之后
Worm storage By ByteOutputStream
w2::a(853):b(119):c(802):d(788):e(199):f(881)

思考：

1）反序列化后的对象，需要调用构造函数重新构造吗？

答案：不需要。对于Serializable对象，对象完全以它存储的二进制位作为基础来构造，而不调用构造器。

请看下面这段代码

package test.serializable;

import java.io.Serializable;
import java.util.Date;

/**
*
* @author chenfei
*
* 用于测试序列化时的deep copy
*
*/
public class House implements Serializable {
private static final long serialVersionUID = -6091530420906090649L;

private Date date = new Date(); //记录当前的时间

public String toString() {
return "House:" + super.toString() + ".Create Time is:" + date;
}

}

package test.serializable;

import java.io.Serializable;

public class Animal implements Serializable {
private static final long serialVersionUID = -213221189192962074L;

private String name;

private House house;

public Animal(String name , House house) {
this.name = name;
this.house = house;
System.out.println("调用了构造器");
}

public String toString() {
return name + "[" +super.toString() + "']" + house;
}

}

package test.serializable;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Myworld {

/**
* @param args
* @throws IOException
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws IOException, ClassNotFoundException {
House house = new House();
System.out.println("序列化前");
Animal animal = new Animal("test",house);
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(out);
oos.writeObject(animal);
oos.flush();
oos.close();

System.out.println("反序列化后");
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
ObjectInputStream ois = new ObjectInputStream(in);
Animal animal1 = (Animal)ois.readObject();
ois.close();
}

}

运行结果如下所示：

序列化前
调用了构造器
反序列化后

从上面的结果中可以看到，在序列化前，当我们使用
Animal animal = new Animal("test",house);

时，调用了Animal的构造器（打印了输出语句），但是反序列后并没有再打印任何语句，说明并没有调用构造器。

2）序列前的对象与序列化后的对象是什么关系？是("=="还是equal？是浅复制还是深复制？)

答案：深复制，反序列化还原后的对象地址与原来的的地址不同。 我们还是看上面思考1）中给出的代码，前两个类不变化，修改第三个类（MyWorld.java）的部分代码，修改后的代码如下：

package test.serializable;