java static variable serialization

问题

How are the values of static variables persisted during serialization(If at all persisted). I have read similar questions on stack where it says that static variables are inherently transient i.e their state or current values is not serialized.

I was just doing a very simple example where i serialized a class and saved it to a file and then again reconstructed the class from the file.Surprisingly I find that the value of the static variable at and when the serialization happened is saved.

How does this happen. Is this because the class template along with it's instance information is saved during serialization. Here is the code snippet -

public class ChildClass implements Serializable, Cloneable{

    /**
     * 
     */
    private static final long serialVersionUID = 5041762167843978459L;

    private static int staticState;
    int state = 0;

    public ChildClass(int state){
        this.state = state;
        staticState = 10001;
    }

    public String toString() {
        return "state" + state + " " + "static state " + staticState;
    }

    public static void setStaticState(int state) {
        staticState = state;
    }

and here is my main class

public class TestRunner {

    /**
     * @param args
     */
    public static void main(String[] args) {
        new TestRunner().run();
    }

    public TestRunner() {

    }

    public void run() {
        ChildClass c = new ChildClass(101);
        ChildClass.setStaticState(999999);
        FileOutputStream fo = null;
        ObjectOutputStream os = null;

        File file = new File("F:\\test");
        try {
            fo = new FileOutputStream(file);
            os = new ObjectOutputStream(fo);
            os.writeObject(c);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {

            try {
                if(null != os)os.close();
                if(null != fo) fo.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }


        FileInputStream fi = null;
        ObjectInputStream ois = null;
        ChildClass streamed;

        try {
            fi = new FileInputStream(file);
            ois = new ObjectInputStream(fi);
            Object o = ois.readObject();
            if(o instanceof ChildClass){
                streamed = (ChildClass)o;
                //ChildClass cloned = streamed.clone();
                System.out.println(streamed.toString());
            }
        } catch (IOException | ClassNotFoundException  e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                if(null != ois)ois.close();
                if(null != fi) fi.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    }

Note : There is nothing wrong with the code. I just am wondering how the value of the static variable 'staticState' in the class 'ChildClass' gets saved. Will the state be saved if i transmit this serialized data over a network then

回答1:

The static field value was not serialized. The output is printing the new value of the static field simply because you modified it to 999999 but you never reset its value to the old one before de-serizalizing. Since the field is static, the new value is reflected in any instance of ChildClass.

To properly assert that the field is not serialized, reset the value to 10001 before de-serializing the object, and you will notice that its value is not 999999.

...
ChildClass.setStaticState(10001);

FileInputStream fi = null;
ObjectInputStream ois = null;
ChildClass streamed;

...
// when de-serializing, the below will print "state101 static state 10001"
System.out.println(streamed.toString());

来源：https://stackoverflow.com/questions/26959034/java-static-variable-serialization