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變量的，大家在使用的時候一定不要混淆。