Java 7之基础 - 序列化与反序列化
转载请注明出处：http://blog.csdn.net/mazhimazh/article/details/20292331
使用Java的序列化和反序列化可以实现信息的持久存储、或者也可以实现Java对象的深克隆。在前面文章讲解过使用序列化和反序列化来实现对象克隆，如下：
Java之基础 - 深克隆与浅克隆（参见文章：http://blog.csdn.net/mazhimazh/article/details/16828505）
下面来具体讲解一下序列化。能够进行序列化的类必须要实现Serializable接口，这个接口的定义如下：
public interface Serializable { }这个接口仅用作一个标识，表示这个类可以进行序列化和反序列化。典型代码如下：
class Shitt implements Serializable{ // 必须实现Serializable接口 }
将如下的类进行序列化和反序列化时继承序列化接口：
class Shitt implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
进行类的序列化和反序列化操作：
public static void save(Shitt t) { // 序列化给定的类
try {
FileOutputStream fs = new FileOutputStream("test.txt");
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(t);
os.flush();
os.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
public static void read() { //反序列化给定的类
try {
FileInputStream fs = new FileInputStream("test.txt");
ObjectInputStream ois = new ObjectInputStream(fs);
Shitt login = (Shitt) ois.readObject();
System.out.println(login.getName());
ois.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
需要注意的几个几点：
（1）在每个要序列化的类中加入private static final 的serialVersionUID，这样，即使在某个对象被序列化之后，它所对应的类被修改了，该对象也依然可以被正确地反序列化。举个例子：
public class MeTest{
public static void main(String[] args) {
Shitt t = new Shitt();
t.setName("mazhi");
MeTest.save(t);
MeTest.read();
}
// 省略save()和read()方法
}最终运行的结果如下：
mazhi
现在修改序列化类为：
class Shitt implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
private int p;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getP() {
return p;
}
public void setP(int p) {
this.p = p;
}
}
现在只调用read()方法进行读取操作，可以看到能够正常读取。去掉serialVersionUID属性或修改后报错：
local class incompatible:
实现序列化接口的实体能够兼容先前版本,不修改这个变量值的序列化实体都可以相互进行串行化和反串行化。
（2）如果一个类中有引用类型的实例变量，这个引用类型也要实现Serializable接口。否则就会抛出异常。或者在不实例Serializable接口时，为这个引用变量加上transient关键字即可。
首先说明一下引用类型的实例变量怎么理解，如下：
class Father{ } // 没有实现Serializable接口
class Shitt implements Serializable{
private String name;
public Father t;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
但是在进行序列化的时候不使用这个t，也就只是声明而不进行实例同样不会出现错误。如果要进行实例化，就需要实现接口，或者加上transient关键字也行，然后再序列化后就不会出错，如下：
Shitt t = new Shitt();
t.setName("mazhi");
t.t=new Father();
MeTest.save(t);
MeTest.read();
一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。
（3）被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。
class Father{
public int a;
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
}
class Shitt extends Father implements Serializable{
private String name;
public static String str="my name is mazhi";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
在这个类中，到底哪些变量的值能够进行序列化，哪些不能呢？测试如下：
Shitt t = new Shitt();
t.setName("mazhi");
t.a=3;
MeTest.save(t);
MeTest.read();在read()方法中打印str和a的值：
System.out.println(login.getName()+" "+login.a); System.out.println(login.str);最终运行的结果如下：
mazhi 0
my name is mazhi
可以看出Father类没有实现序列化接口，其定义的属性不能被序列化。最需要注意的是静态变量，这个变量不被序列化，那为什么还可以读出值呢？
因为在类加载时这个变量已经存在于内存中了，而且保持着唯一，不会被垃圾回收。当再运行时，由于静态变量属于类，当然可以取出这个值了。我们可以在另外一个虚拟机上进行测试就不会出现这个问题了。
同时从这个例子还能得出一些结论：
如果一个类实现了Serializable接口，但是它的父类没有实现，那么这个类也可以序列化。需要提醒的是Object超类没有实现这个序列化的接口。为什么呢？？因为如果一个类没有实现Serializable接口，但是它的父类实现了，那么这个类也可以序列化。Object实现序列化接口意味着所有的类都可以被序列化，这一概念变得无意义，现时还会造成各种问题。
（4）序列化和反序列化过程中构造函数的调用
class Father{ // 没有实现Serializable接口
public Father(){
System.out.println("父类构造方法");
}
}
class Shitt extends Father implements Serializable{
public Shitt(){
System.out.println("子类构造方法");
}
}
对Shitt类进行序列化和反序列化后的运行结果如下：
父类构造方法
子类构造方法
父类构造方法
父类加上序列化接口后再次进行序列化和反序列化的操作，结果如下：
父类构造方法
子类构造方法
由上可以得出结论：在进行反序列化过程中还是遵守类的初始化规则，也就是先父类后子类，但是子类的初始化并不是通过调用构造函数等手段，而是从持久化文件中存储的信息进行初始化的。
扩展：
（1）其实可以在类的序列化过程中，指定属性存储的格式，例如XML，反序列化也是一样的，有兴趣的话可以参见其他资料。
（2）既然序列化和反序列化可以实现文件的持久存取，那么与其他一些持久化，例如数据库比起来又怎么样呢？