Java序列化与反序列化 & 深拷贝

package com.main.domain;
public enum Gender {
	// 枚举类型都会默认继承类java.lang.Enum，而该类实现了Serializable接口，所以枚举类型对象都是默认可以被序列化的。
	MALE, FEMALE
}

package com.main.domain;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

/**
 * Java序列化采用了一种特殊的序列化算法，其算法内容如下： 
 * 所有保存到磁盘中的对象都有一个序列化编号； 
 * 当程序视图序列化一个对象时，程序将先检查该对象是否已经被序列化过，只有该对象从未（在本次虚拟机）中序列化过，系统才会将该对象转换成字节序列并输出； 
 * 如果某个对象已经序列化过，即使该对象某些属性有改动，程序也只是直接输出一个序列化编号，而不是再次重新序列化该对象。
 */
public class Person implements Externalizable {
	// Serializable接口中没有任何方法属性域，可以理解为一个标记，即表明这个类可以序列化。
	// Externalizable继承于Serializable，有两个方法，当使用该接口时，序列化的细节需要由程序员去完成。

	// 对象序列化不会关注类中的方法、static Field（即静态Field）、transient Field（也被称为瞬态Field）。
	// 序列版本UID，目的是序列化对象版本控制。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。
	private static final long serialVersionUID = 1L;

	private String name = null;
	transient private Integer age = null;// 当某个字段被声明为transient后，默认序列化机制就会忽略该字段。
	private Gender gender = null;

	// 使用Externalizable进行序列化，当读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。
	// 因此实现Externalizable接口的类必须要提供一个无参的构造器，且它的访问权限为public，否则报错。
	public Person() {
		System.out.println("none-arg constructor of person");
	}

	public Person(String name, Integer age, Gender gender) {
		System.out.println("arg constructor of person");
		this.name = name;
		this.age = age;
		this.gender = gender;
	}

	public String getName() {
		return name;
	}

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

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public Gender getGender() {
		return gender;
	}

	public void setGender(Gender gender) {
		this.gender = gender;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", gender=" + gender
				+ "]";
	}

	// /////////////////////////////Serializable相关的自定义序列化机制:////////////////////////////////////////////////////

	// writeObject()与readObject()都是private方法，那么它们是如何被调用的呢？毫无疑问，是使用反射。
	// 详情可见ObjectOutputStream中的writeSerialData方法，以及ObjectInputStream中的readSerialData方法。

	private void writeObject(ObjectOutputStream out) throws IOException {
		System.out.println("writeObject()");
		out.defaultWriteObject();// defaultWriteObject()方法会执行默认的序列化机制，此时会忽略掉age字段。
		out.writeInt(age);// writeInt()方法显示地将age字段写入到ObjectOutputStream中，即使该字段为transient。
	}

	private void readObject(ObjectInputStream in) throws IOException,
			ClassNotFoundException {
		System.out.println("readObject()");
		in.defaultReadObject();
		age = in.readInt();
	}

	// 当反序列化是遇到如下异常会自动调用readObjectNoData方法：i. 序列化版本不兼容；ii. 输入流被篡改或者损坏；
	// 该方法的目的就是在发生上面这些异常时给对象提供一个合理的值（比如默认值或者全是0、null之类的，视具体情况而定）。
	// 但是如果反序列化时接受的类不存在还是会抛出异常的，毕竟该方法最终还是会还原出一个对象来，而对象的存在是以类的存在为前提的，所以没有类还是不行的。
	private void readObjectNoData() throws ObjectStreamException {
		System.out.println("readObjectNoData()");
	}

	/**
	 * 无论是实现Serializable接口还是Externalizable接口，程序在自定义序列化之前，都会先调用writeReplace()方法，
	 * 在序列化对象时将该对象替换成方法返回替换后的对象，方法返回的对象要与序列化前的对象要兼容，否则，会抛出 ClassCastException。
	 *
	 * 注意：
	 * a.实现writeReplace就不要实现writeObject了，因为writeReplace的返回值会被自动写入输出流中，就相当于自动这样调用：writeObject(writeReplace());
	 * b.因此writeReplace的返回值（对象）必须是可序列化的；
	 * c.但如果返回的是自定义类型的对象，那么该类型必须是彻底实现序列化的。
	 *
	 * writeReplace的替换如何在反序列化时被恢复？
	 * i.注意：不是用readResolve恢复，readResolve并不是用来恢复writeReplace的。
	 * ii.writeReplace替换后无法恢复，即对象被彻底替换了，也就是说使用ObjectInputStream读取的对象只能是被替换后的对象，只能在读取后自己手动恢复。
 	 *	
	 * 结论：writeObject只和readObject配合使用，一旦实现了writeReplace在写入时进行替换就不再需要writeObject和readObject。
	 * 因为替换就已经是彻底的自定义，比writeObject/readObject更彻底！
	 */
	private Object writeReplace() throws ObjectStreamException {
		System.out.println("writeReplace()");
		List