序列化：把对象转换为字节序列的过程称为对象的序列化。
    反序列化：把字节序列恢复为对象的过程称为对象的反序列化。

    1. public class FlyPig implements Serializable {
    3.     //  private static final long serialVersionUID = 1L;
    4.     private static String AGE = "269";
    5.     private String name;
    6.     private String color;
    7.     transient private String car;
    9.     private String addTip;
    11.     public String getName() {
    12.         return name;
    13.     }
    15.     public void setName(String name) {
    16.         this.name = name;
    17.     }
    19.     public String getColor() {
    20.         return color;
    21.     }
    23.     public void setColor(String color) {
    24.         this.color = color;
    25.     }
    27.     public String getCar() {
    28.         return car;
    29.     }
    31.     public void setCar(String car) {
    32.         this.car = car;
    33.     }
    35.     public String getAddTip() {
    36.         return addTip;
    37.     }
    39.     public void setAddTip(String addTip) {
    40.         this.addTip = addTip;
    41.     }
    43.     @Override
    44.     public String toString() {
    45.         return "FlyPig{" +
    46.                 "name='" + name + '\'' +
    47.                 ", color='" + color + '\'' +
    48.                 ", car='" + car + '\'' +
    49.                 ", AGE='" + AGE+ '\'' +
    50.                 '}';
    51.     }
    52. }
    1. public class SerializableTest {
    2.     public static void main(String[] args) throws Exception {
    3.         serializeFlyPig();
    4.         FlyPig flyPig = deserializeFlyPig();
    5.         System.out.println(flyPig.toString());
    6.     }
    8.     /**
    9.      * 序列化
    10.      */
    11.     private static void serializeFlyPig() throws Exception {
    12.         FlyPig flyPig = new FlyPig();
    13.         flyPig.setColor("black");
    14.         flyPig.setName("riemann");
    15.         flyPig.setName("audi");
    16.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("d:/flypig.txt")));
    17.         oos.writeObject(flyPig);
    18.         System.out.println("FlyPig 对象序列化成功！");
    19.         oos.close();
    20.     }
    22.     /**
    23.      * 反序列化
    24.      */
    25.     private static FlyPig deserializeFlyPig() throws Exception {
    26.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("d:/flypig.txt")));
    27.         FlyPig pig = (FlyPig) ois.readObject();
    28.         System.out.println("FlyPig 对象反序列化成功！");
    29.         return pig;
    30.     }
    32. }

    结果：序列化成功，静态变量没有序列化，transient修饰的成员变量没有不被实例化。

    1. 不实现Serializable接口，序列化和反序列化会出现NotSerializableException异常。
    2. 实现Serializable接口，注释addtip成员变量，先序列化，然后取消addtip成员变量的注释，反序列化发现出现异常InvalidClassException 。
    3. 我在实体类中没有设置serialVersionUID 赋值，但是Java会自动给我们赋值。添加addTip属性时候，会再次生成serialVersionUID 值，两次的值不一样就会抛异常了。

    处理方案：添加 private static final long serialVersionUID = 1L后继续之前这个操作，发现序列化，反序列化没有出现问题。