/*
 * zt
 * 2020/8/8
 * 15:34
 *序列化：把Person对象写入硬盘中
 要求：1.序列化的类必须是Serializable自动或者Externalizable手动序列化接口
      2.序列化的类要添加一个私有的long类型静态常量serialVersionUID，保证序列化的类反序列化的类是同一个类。
      (1)使用transient修饰的属性，不可以序列化
      (2)静态属性不能序列化

      面试题:使用transient的属性一定不能序列化吗?  能 , 使用 Externalizable 实现。

      @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(name);
        out.writeObject(age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        name=(String)in.readObject();
        age=(int)in.readObject();
    }
 */

import java.io.*;
import java.util.ArrayList;

public class Demo3 {
    public static void main(String[] args) throws Exception {
//        writeObject();
        readObject();
    }
    //序列化
    public static void writeObject() throws Exception {
        //创建ObjectOutoutStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e:\aaa.txt"));
        //创建对象
        Person zhuxi = new Person("aa",20);
        Person xiongfei = new Person("bb",20);
        Person.country="china";
        ArrayList<Person> list = new ArrayList<>();
        list.add(zhuxi);
        list.add(xiongfei);
        oos.writeObject(list);
        oos.close();
        System.out.println("序列化成功");

    }
    //反序列化
    public static void readObject() throws Exception {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e:\aaa.txt"));
        ArrayList<Person> list = (ArrayList<Person>) ois.readObject();
        for (Person person : list) {
            System.out.println(person.toString());
        }
        System.out.println(Person.country);
        ois.close();
    }


}

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Person implements Externalizable,Cloneable {
    //serialVersionUID
    private static final long serialVersionUID=1000L;
    private String name;
    private transient int age;
    public static String country="中国";

    private Address add;


    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("带参构造执行了");
    }

    public Person() {
        System.out.println("无参构造执行了");
    }

    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;
    }

    public Address getAdd() {
        return add;
    }

    public void setAdd(Address add) {
        this.add = add;
    }

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

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(name);
        out.writeObject(age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        name=(String)in.readObject();
        age=(int)in.readObject();
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        Person p=(Person)super.clone();
        p.setAdd((Address) add.clone());
        return p;
    }
}

public class Address implements Cloneable{
    private String city;
    private String area;

    public Address(String city, String area) {
        this.city = city;
        this.area = area;
    }
    public Address() {

    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getArea() {
        return area;
    }

    public void setArea(String area) {
        this.area = area;
    }

    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + ''' +
                ", area='" + area + ''' +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

无参构造执行了
无参构造执行了
Person{name='aa', age=20}
Person{name='bb', age=20}
中国