7 
public class MySerializable implements Serializable{

    private int x=10;
    private static int y = 15;
    public static void main(String...args){
        AnotherClass a = new AnotherClass();
        AnotherClass b;
        //Serialize
        try {
            FileOutputStream fout = new FileOutputStream("MyFile.ser");
            ObjectOutputStream Oout = new ObjectOutputStream(fout);
            Oout.writeObject(a);
            System.out.println( a.toString());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        //De-serialize
        try {
            FileInputStream fis = new FileInputStream("MyFile.ser");
            ObjectInputStream  Oin = new ObjectInputStream (fis); 
            b = (AnotherClass) Oin.readObject();
            System.out.println( b.toString());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }

    }
}

class AnotherClass  implements Serializable{  

    transient int x = 8;  
    static int y = 9;  

    @Override  
    public String toString() {  
        return "x : " + x + ", y :" + y;  
    }  
}

你能告诉我静态变量是如何序列化的吗？

4

5 回答 5

11

显然，静态变量可以序列化（但你不应该这样做），因为序列化是保存类实例状态的过程，并且静态变量对所有实例都是通用的。他们没有说任何关于实例的状态，所以，它根本没有意义。

假设您被允许序列化一个静态变量。然后，当您反序列化实例时，您将获得该变量的旧副本，从那时起可能已更改。由于静态变量在类的所有实例之间共享，因此任何实例对变量的更改都必须反映在该实例中。

因此，它们不应该被序列化，因为在这些条件下的变量可能会违反其作为静态变量的合同。

序列化： -

  • 不应该序列化静态变量..

反序列化： -

  • 实例将获得与类一起加载的静态字段。因此，可能对该变量所做的任何更改也将对该实例负责。
于 2012-10-08T05:56:12.513 回答
2

MySerializable 类的当前输出如下

x : 8, y :9
x : 0, y :9

在这种情况下，静态变量在调用toString() 方法后被打印出来，此时它将从类级变量中读取值。

尝试这个：

在 MySerializable 类中添加这行代码在//Serializeblock之后

AnotherClass.y = 5;

输出是：

x : 8, y :9
x : 0, y :5

这意味着静态变量没有存储在文件中，它将通过 toString() 方法动态读取。

于 2012-10-08T07:37:40.360 回答
0

- Serialization用于在序列化过程中保存对象的状态，因此在反序列化过程中，可以使用保存的状态来恢复堆上的相同对象。

- 是 static的变量可以，serialized但它没有任何意义.....

于 2012-10-08T05:59:34.133 回答
0

静态变量不能也不能序列化。

您的问题似乎是基于这样一个事实，即您在序列化之后从静态变量中看到与序列化之前相同的值，但这不是因为值被序列化和恢复。

这种行为是因为该静态变量的静态初始化程序将其设置为 9，并且它永远不会更改。

要验证静态变量是否未序列化，您可以执行 NPKR 的建议更改，在序列化和反序列化之间修改静态字段，或者您可以执行以下操作：

运行这个程序，然后注释掉执行序列化的位。结果，您将在磁盘上拥有旧的序列化版本。

然后将静态字段的静态初始化器更改为y = 5，再次运行程序：您将得到 'x: 0 y: 5 as the output, because the value9` of the static field was not restores。

于 2014-09-08T17:08:16.283 回答
0 

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

class TestJava implements Serializable{
    public static int k = 10;
    public int j=5;
public static void main(String[] args) {
    
    TestJava tj1= new TestJava();
    TestJava tj2;
    
    
        try{ //serialization
            FileOutputStream fos = new FileOutputStream("myclass.ser");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(tj1);
            oos.close();
            fos.close();
            System.out.println("object serielized 1..."+tj1.j);
            System.out.println("object serielized 2..."+tj1.k);
            System.out.println("object serielized 3..."+k);
            k=++k; // 'k' value incrementd after serialization
          } catch(FileNotFoundException fnfe){
             fnfe.printStackTrace();
          } catch(IOException ioex){
             ioex.printStackTrace();
          }
    
      
          try{ //deserialization
              FileInputStream fis = new FileInputStream("myclass.ser");
              ObjectInputStream ois = new ObjectInputStream(fis);
              tj2 = (TestJava) ois.readObject();
              ois.close();
              fis.close();
              System.out.println("object DEEEEserielized 1..."+tj2.j);
              System.out.println("object DEEEEserielized 2..."+tj2.k); 
              System.out.println("object DEEEEserielized 3..."+k); 
            // in deserialization 'k' value is shown as incremented. 
            // That means Static varialbe 'K' is not serialized.
            // if 'K' value is serialized then, it has to show old value before incrementd the 'K' value.
            } catch(FileNotFoundException fnfe){
              fnfe.printStackTrace();
            } catch(IOException ioex){
              ioex.printStackTrace();
            } catch(ClassNotFoundException CNFE){
              CNFE.printStackTrace();                   
           }
      }
}

/* Output of the above program
 
object serielized 1...5
object serielized 2...10
object serielized 3...10
object DEEEEserielized 1...5
object DEEEEserielized 2...11
object DEEEEserielized 3...11


*/

于 2015-02-01T17:19:16.743 回答