Java序列化与static

简介：

Java序列化，就是指将一个对象转化为二进制的byte流（注意，不是bit流），然后以文件的方式进行保存。

序列化操作：将对象保存至文件；

反序列化操作：从文件恢复出对象；

配置：

对象如果要序列化，则必须集成Serializable接口；

在实现序列化时，用ObjectOutputStream实现；

而反序列化时，用ObjectInputStream实现；

方法：

1. 序列化：

(1) public ObjectOutputStream(OutputStream out) throws IOException

(2) public final void writeObject(Object obj)

(3) public void close() throws IOException

2.反序列化：

(1) public ObjectInputStream(InputStream in) throws IOException

(2) public final void readObject(Object obj)

(3) public void close() throws IOException

注意：

Java序列化是不能序列化static变量的，因为其保存的是对象的状态，而static变量保存在全局数据区，在对象未实例化时就已经生成，属于类的状态。

为了方便理解，我们举例说明：

例子：

首先附上我们要序列化的对象的生成类：

package test;

import java.io.Serializable;

public class Person implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private String name;
	private int age;
	
	public static String test="IBM";
	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;
	}
}

这里我们有static变量test，赋值为IBM。

下面我们来看两个代码：

package test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

public class Main{
	
	public static void main(String[] args){
		
		Person person = new Person();
		person.setAge(25);
		person.setName("YXY");
		Person.test="JAVA"; //modify the test value
		
		File file = new File("c:/test.txt");
		try {
			OutputStream out = new FileOutputStream(file);
			ObjectOutputStream objout = new ObjectOutputStream(out);
			objout.writeObject(person);
			objout.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		//code segment 1
		Person perobj = null;
		try {
			InputStream in = new FileInputStream(file);
			ObjectInputStream objin = new ObjectInputStream(in);
			perobj = (Person)objin.readObject();
			System.out.println(perobj.test);
			in.close();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
}

在这段代码里，一开始我们就改了static变量test的值为JAVA，然后在code segment 1上面我们首先实现了序列化，接着我们在code segment 1下面实现了反序列化，读取对象，运行，我们发现结果是JAVA，这时大家要问了，说不序列化static变量，怎么读取出来的反序列化对象的值，test的值还改变呢？这正是因为我们并没有序列化static变量，所以它并没有被写入流中，所以当我们要读取test的值时，它不可能在反序列化的文件里找到新的值，而是去全局数据区取值，因为全局数据区的值现在是JAVA，所以读取出来的值就是改变后的值JAVA了。

下面我们再看一段代码：

package test;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;

public class TEST {
	public static void main(String[] args){
		File file = new File("c:/test.txt");
		
		//code segment 1
		Person perobj = null;
		try {
			InputStream in = new FileInputStream(file);
			ObjectInputStream objin = new ObjectInputStream(in);
			perobj = (Person)objin.readObject();
			System.out.println(perobj.test);
			in.close();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
}

同样也是反序列化操作，只不过放到了另一个文件里，这时再运行，结果就是IBM，不再是之前的JAVA，正是因为我们并没有序列化static变量，所以test的值并不会改变，因为运行这个文件时，全局数据区里的static变量也没有改，所以它一如既往的是它的原始值IBM。

总结，综上所述，Java序列化是不能序列化static变量的，大家在使用的时候一定不要混淆。