java中类实现Serializable接口的原因

背景：一个java中的类只有实现了Serializable接口，它的对象才是可序列化的。如果要序列化某些类的对象，这些类就必须实现Serializable接口。Serializable是一个空接口，没有什么具体内容，它的目的只是简单的标识一个类的对象可以被序列化。

为什么要进实现Serializable接口：为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来，这是java中的提供的保存对象状态的机制—序列化。

在什么情况下需要使用到Serializable接口呢？
　　1、当想把的内存中的对象状态保存到一个文件中或者数据库中时候；
　　2、当想用套接字在网络上传送对象的时候；
　　3、当想通过RMI传输对象的时候；
　　
serialVersionUID
serialVersionUID的取值是Java运行时环境根据类的内部细节自动生成的。如果对类的源代码作了修改，再重新编译，新生成的类文件的serialVersionUID的取值有可能也会发生变化。类的serialVersionUID的默认值完全依赖于Java编译器的实现，对于同一个类，用不同的Java编译器编译，有可能会导致不同的serialVersionUID，也有可能相同。为了提高serialVersionUID的独立性和确定性，强烈建议在一个可序列化类中显示的定义serialVersionUID，为它赋予明确的值。显式地定义serialVersionUID有两种用途：
　　a. 在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的serialVersionUID；
　　b. 在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的serialVersionUID。

代码实现：
在这里 定义一个实现了Serializable接口的Person类

import java.io.Serializable;

public class Person implements Serializable {
    private int id;
    private String name;
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

再定义一个SerializationUtils类来模拟 序列化和反序列化的过程

import java.io.*;

public class SerializationUtils {
    private static String FILE_NAME = "f:/obj";
    //序列化  写的过程
    public static void write(Serializable s){
        try {
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(FILE_NAME));
            objectOutputStream.writeObject(s);
            objectOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //反序列化 读的过程
    public static Object read(){
        Object obj=null;
        // 反序列化
        try {
            ObjectInput input = new ObjectInputStream(new FileInputStream(FILE_NAME));
            obj = input.readObject();
            input.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return obj;
    }
}

测试函数

import com.txp.SerializationUtils;
import org.junit.Test;

public class testSerializable {
   @Test
    public  void testWrite(){
        Person person=new Person();
        person.setId(1);
        person.setName("张丹");
        SerializationUtils.write(person);
    }

    @Test
    public  void testRead(){
        Person p = (Person) SerializationUtils.read();
        System.out.println(p.getName());
    }
}

先运行testWrite()实现序列化持久化，再运行testRead()实现反序列化读出数据 ，这一次的Person类中没有给定serialVersionUID，结果会输出‘张丹’。

如果此时给Person类加一个属性 age，运行testRead()，会抛出会抛出 java.io.InvalidClassException异常。因为JVM在反序列化时，会比较数据流中的serialVersionUID与类的serialVersionUID是否相同，如果相同，则认为类没有发生改变，可以把数据流load为实例对象；如果不相同，对不起，JVM会抛异常InvalidClassException，这是JVM一个很好的一个校验机制，确保类的一致性。

但是如果显式给定serialVersionUID（而隐式声明则是我不声明，编译器在编译的时候帮我生成。），即是 private static final long serialVersionUID = XXL;，修改Person类如下:

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private int id;
    private String name;
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

再进行同样的操作过程，则不会抛出异常，会打印出结果。但是最好不要这样操作，要在类修改后，先序列化，再但序列化。确保类的前后一致性。
参考文章：
https://www.cnblogs.com/yoohot/p/6019767.html
https://blog.csdn.net/jaryle/article/details/52598296
http://www.cnblogs.com/DreamDrive/p/5412931.html