Serialization of static variables

[Sandeep Reddy Vinta]

I read java serialization doesn't include static variable's data. But when i run the following java file it does. It retains the value of the static variable. Can anyone explain why

Code

package com.serialization;
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;
public class SerTest {
public static void main(String[] args) {
ABC a = new ABC();
try {
ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("serialization.ser"));
os.writeObject(a);
os.close();
System.out.println("Before Serialization :" + a.toString());
ObjectInputStream is = new ObjectInputStream(new FileInputStream("serialization.ser"));
ABC aNew = (ABC) is.readObject();
is.close();
System.out.println("ABCfter Serialization :" + aNew.toString());
} catch (FileNotFoundException e) {
// TODO ABCuto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO ABCuto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO ABCuto-generated catch block
e.printStackTrace();
}
}
}
class ABC implements Serializable{
static int y = 9;
transient int x = 8;
public ABC() {
y = 20;
}
@Override
public String toString() {
return "x : " + x + ", y :" + y;
}
}

Output :


Before Serialization :x : 8, y :20
ABCfter Serialization :x : 0, y :20



If you observe the static variable y before serialization is initialized to 9 and later changed to 20 in constructor. After serialization is done. Now Deserializing the class shouldn't retain the static variable content according to my assumption : "java serialization doesn't include static variable's data". Why is this happening.

[Rob Spoor]

Welcome to the Ranch!

Variable y is static. That means that as long as the class is loaded, it will keep the same value. You are serializing and de-serializing inside the same JVM instance.

Try splitting the serialization and de-serialization into two classes and see the difference:

public class SerTest {
public static void main(String[] args) {
ABC a = new ABC();
try {
ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("serialization.ser"));
os.writeObject(a);
os.close();
System.out.println("Before Serialization :" + a.toString());
} catch (IOException e) {
// TODO ABCuto-generated catch block
e.printStackTrace();
}
}
}
class DeSerTest {
public static void main(String[] args) {
try {
ObjectInputStream is = new ObjectInputStream(new FileInputStream("serialization.ser"));
ABC aNew = (ABC) is.readObject();
is.close();
System.out.println("ABCfter Serialization :" + aNew.toString());
} catch (FileNotFoundException e) {
// TODO ABCuto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO ABCuto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO ABCuto-generated catch block
e.printStackTrace();
}
}
} 

Now run java SerTest first, then java DeSerTest.

And please UseCodeTags next time.

[Sandeep Reddy Vinta]

Thanks Rob for your reply. I'll definitely take your suggestions.

I want to check whether i understood the behavior of the code properly.


In the above code i have posted.


Serialization Process.

Will not store the static information.


Desirialization Process.

Will get the static field information by loading the class. As the class ABC is already
loaded into the JVM, it refers to the static field which is already existing in the memory.
As it is changed in the constructor, the deserialization would pick the changed one from the memory.



Is this understanding proper.

[Rob Spoor]

That looks to be a good summary, yes.