java序列化demo

public class Testtest {
    public static void main(String[] args) throws IOException,ClassNotFoundException {
        // Person对象文件路径
        String path = "d:/person.dat";
        // 创建一个Person对象
        Person1 p1 = new Person1("ddd",33);
        System.out.println(p1);
        // 序列化Person对象
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(path));
        out.writeObject(p1);
        out.close();

        // 反序列化
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(path));
        Person1 p2 = (Person1) in.readObject();
        in.close();
        // 打印反序列化的结果
        System.out.println("p2: " + p2);
        System.out.println(p2.getName());
        System.out.println(p2.getAge());
        System.out.println(p2.getSex());
        // 反序列化后对象的内存地址和原来的地址不同，是深拷贝。
        System.out.println("p1 == p2 is: " + (p1 == p2));
    }
}
class Fu {
    private  String sex="nan";

    public String getSex() {
        return sex;
    }
}

class  Person1 extends Fu implements Serializable{
   private  String name;
    private int age;
    private static final Person1 INSTANCE = new Person1();

    public Person1() {
       name ="dddddbbbb";
    }

    public Person1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static Person1 getInstance() {
        return INSTANCE;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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


    private Object writeReplace() throws ObjectStreamException {
        System.out.println("writeReplace");
        return INSTANCE;
    }

    /**
     * 序列化transient修饰的字段,通过ObjectOutputStream把想要序列化的transient字段写出去。
     * <p>
     * 访问控制符必须是private，一定要先执行out.defaultWriteObject();
     *
     * @param out ObjectOutputStream
     * @throws IOException
     */
    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();
        out.writeObject(name+"22");
        out.writeInt(age +10);
    }

    /**
     * 反序列化transient修饰的字段，通过ObjectInputStream把transient字段读出来
     * <p>
     * 访问控制符必须是private，一定要先执行in.defaultReadObject();
     *
     * @param in ObjectInputStream
     * @throws IOException
     */
    private void readObject(ObjectInputStream in) throws IOException,
            ClassNotFoundException {
        in.defaultReadObject();
        name= (String) in.readObject();
        age = in.readInt() - 20;
    }
    private Object readResolve() throws ObjectStreamException {
        System.out.println("readResolve");
        return INSTANCE;
    }
}

java 序列化中顺序是writeReplace(),writeObject(),readObject(), readResolve()所以我们想干扰序列化过程可以在这些方法里进行处理,例如单例保证是同一个对象的话,可以在
 readResolve()方法里返回单例对象;等等