serialVersionUID的作用、java的序列化/反序列化

    serialVersionUID就是用来表明类的不同版本之间的兼容性，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常(InvalidClassExceptions)。实现了Serializable接口的类，如果没有主动在程序中加上serialVersionUID，那么编译器会提示加上serialVersionUID值：一个是默认的1L， 一个是根据类名、接口名、成员方法及属性等生成的一个64位的哈希字段。

    Java序列化技术可以使你将一个对象的状态写入一个Byte流里，并且可以从其它地方把该Byte流里的数据读出来，重新构造一个相同的对象。这种机制允许你将对象通过网络进行传播，并可以随时把对象持久化到数据库、文件等系统里。用途：利用对象的序列化实现保存应用程序的当前工作状态，下次再启动的时候将自动地恢复到上次执行的状态。
    如果某个类能够被序列化，其子类也可以被序列化。如果该类有父类，则分两种情况来考虑，如果该父类已经实现了可序列化接口。则其父类的相应字段及属性的处理和该类相同；如果该类的父类没有实现可序列化接口，则该类的父类所有的字段属性将不会序列化。
    声明为static和transient类型的成员数据不能被序列化。因为static代表类的状态， transient代表对象的临时数据；
    相关的类和接口：在java.io包中提供的涉及对象的序列化的类与接口有ObjectOutput接口、ObjectOutputStream类、ObjectInput接口、ObjectInputStream类。
    1)ObjectOutput接口：它继承DataOutput接口并且支持对象的序列化，其内的writeObject()方法实现存储一个对象。

    2)ObjectInput接口：它继承DataInput接口并且支持对象的序列化，其内的readObject()方法实现读取一个对象。
    3)ObjectOutputStream类：它继承OutputStream类并且实现ObjectOutput接口。利用该类来实现将对象存储（调用ObjectOutput接口中的writeObject()方法）。

    4)ObjectInputStream类：它继承InputStream类并且实现ObjectInput接口。利用该类来实现读取一个对象（调用ObjectInput接口中的readObject()方法）

针对序列化与反序列化，这里写了一个Demo：

<span style="font-family:Courier New;font-size:14px;">/**
 * Program  : SerialDemo
 * Author   : yajun.liu
 * Create   : 2014年7月30日 下午9:26:23
 *
 * Copyright 2014 By yajun.liu, All rights reserved.
 *
 * 测试序列化与反序列化,了解serialVersionUID的作用.
 */
package com.liuyj.app;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;


/**
* 测试序列化与反序列化.
* @author yajun.liu
* @since
* @param
*/
public class Person implements Serializable {

    /** 序列号. */
    private static final long serialVersionUID = 1L;
    /** 名称. */
    private String name;
    /** 年龄. */
    private int age;
    /** 性别. */
    private String sex;
    /**
    * 构造函数.
    * @author yajun.liu
    * @create 2014-7-30 上午10:15:20
    * @since
    * @param nam 名称
    * @param ag 年龄
    * @param sx 性别
    * @return
    */
    public Person(String nam, int ag, String sx) {
        this.name = nam;
        this.age = ag;
        this.sex = sx;
    }

    /**
    * getter.
    * @author yajun.liu
    * @create 2014-7-30 上午10:15:22
    * @since
    * @param
    * @return name
    */
    public String getName() {
        return this.name;
    }
    /**
    * setter.
    * @author yajun.liu
    * @create 2014-7-30 上午10:15:24
    * @since
    * @param nam 名字
    * @return
    */
    public void setName(String nam) {
        this.name = nam;
    }

    /**
    * getter.
    * @author yajun.liu
    * @create 2014-7-30 上午10:15:26
    * @since
    * @param
    * @return age
    */
    public int getAge() {
        return this.age;
    }
    /**
    * setter.
    * @author yajun.liu
    * @create 2014-7-30 上午10:15:28
    * @since
    * @param ag 年龄
    * @return
    */
    public void setAge(int ag) {
        this.age = ag;
    }

    /**
    * getter.
    * @author yajun.liu
    * @create 2014-7-30 上午10:15:29
    * @since
    * @param
    * @return sex
    */
    public String getSex() {
        return this.sex;
    }
    /**
    * setter.
    * @author yajun.liu
    * @create 2014-7-30 上午10:15:32
    * @since
    * @param sx 性别
    * @return
    */
    public void setSex(String sx) {
        this.sex = sx;
    }

    /**
    * main.
    * @author yajun.liu
    * @create 2014-7-30 上午10:15:34
    * @since
    * @param args 参数
    * @return
    */
    public static final void main(String[] args) {
        Person person = new Person("liuyj", 22, "男");
        try {
            //将对象流化到文件中存储,序列化
            FileOutputStream fos = new FileOutputStream("a.txt");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(person);
            System.out.println("Person---Write");
            System.out.println("Name is: "+person.getName());
            System.out.println("Age is: "+person.getAge());
            System.out.println("Sex is: "+person.getSex());
            oos.flush();
            oos.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    
        try {
            //从文件中读取字节流转换为对象，反序列化
            FileInputStream fis = new FileInputStream("a.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);
            person = (Person) ois.readObject();
            System.out.println("--------------------");
            System.out.println("Person---Read");
            System.out.println("Name is: "+person.getName());
            System.out.println("Age is: "+person.getAge());
            System.out.println("Sex is: "+person.getSex());
            ois.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }   
}</span>

在项目代码目录页生成a.txt文件，console打印结果如下：

Person---Write
Name is: liuyj
Age is: 22
Sex is: 男
--------------------
Person---Read
Name is: liuyj
Age is: 22
Sex is: 男

    如果将序列化与反序列化代码分开，当serialVersionUID=1L时，将Person对象写入a.txt中（删除反序列化代码）；这时修改serialVersionUID=2L，删除代码中的序列化过程，反序列化从a.txt中读取对象，Eclipse就会报错(java.io.InvalidClassException)，这就是序列号serialVersionUID作为版本之间兼容性的解答了。