Serialization, Heap and Objects

[Rob Mech]

Howdy, I was writing some sample code on serialization and testing out various parts of it. The code below is throwing me for a loop though because it doesnt make sense WHY something is the way it is. It may be a bug but I dont see how. Can somone explain my results?

Below you'll see that I have 6 boxes total. The first 3 which I create new instances of with new main(); The static variable boxes and the constructor of the class increment how many I have. These reference variables should be set each time the constructor is called on a new instance right? With me so far...

Now, we serialize these objects, and save them to a disk file. I read them in a different order back (because the SCJP study guide didnt mention it and I wanted to see if it worked the way I thought (which it did)). Regardless I read these into different "boxes" Box4, Box6 and Box5. Now I NEVER EVER created instances these objects. In fact they are declared as null.

Once the code reads the objects back in, theoretically it's creating an insance and pointing it to boxes 4,5,6. Here is the kicker. If it's creating new Main instances, why is the static variable not being incremented? If you run this code, the number of "boxes" returns 3. But in reality, you have 6 differnt boxes!

If the rule for statics is that it's the same once the class is "loaded" then I should have 6 right? Ok, I know what youre going to say... I cast it to a Main so therefore it's an Object instance not a Main instance. I'm cool with that BUT, if the generic "Object" doesnt contain my methods (not an IS-A) relationship, how did they get there! Ok, one more

System.out.println(Box6 instanceof Main);

Returns true!!!

I'm sure this is some special serialization thing but I'd like to know how that works. Even if it's not on the SCJP that's just creepy.

Thanks!

/*
 * Main.java
 */
package cerealbox;
 
import java.io.Serializable;
import java.io.*;
import java.lang.reflect.Array;
/**
 *
 * @author rob
 */
public class Main implements Serializable, Runnable{
    static int boxes=0;
    String CerealType = "Frosted Flakes";
    int Calories = 10;
    Float Weight=12.2f;
    
    /** Creates a new instance of Main */
    public Main() {
        boxes+=1;
    }
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        
        // Create three objects
        Main Box1;
        Main Box2;
        Main Box3;
        Main Box4=null;
        Main Box5=null;
        Main Box6=null;
        
        Box1=new Main();
        Box2=new Main();
        Box3=new Main();
        
        // Change the contents of the second boxes from the default
        Box2.CerealType="Trix";
        Box2.Calories=20;
        Box2.Weight=23.32334f;
        
        Box3.CerealType="CoCo Puffs";
        Box3.Calories=22;
        Box3.Weight=13.32334f;
 
        showObject(Box1,"Box1");
        showObject(Box2,"Box2");
        showObject(Box3,"Box3");
 
        System.out.println("There are currently " + boxes + " instances of boxes in the heap");
        FileOutputStream fos;
        try {
            fos = new FileOutputStream("c:\\testSer.ser");
            ObjectOutputStream os = new ObjectOutputStream(fos);
            os.writeObject(Box1);
            os.writeObject(Box2);
            os.writeObject(Box3);
            os.close();
            fos.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        FileInputStream fis;
        try {
            fis = new FileInputStream("c:\\testSer.ser");
            ObjectInputStream is = new ObjectInputStream(fis);
            Box4 = (Main)is.readObject();
            Box6 = (Main)is.readObject();
            Box5 = (Main)is.readObject();
            is.close();
            fis.close();
        }catch (Exception ex){
            ex.printStackTrace();
        }
        showObject(Box4,"Box1");
        showObject(Box5,"Box2");
        showObject(Box6,"Box3");
        System.out.println("There are currently " + boxes + " instances of boxes in the heap");
        System.out.println(Box6 instanceof Main);        
    }
    public void run() {
    }
    public static void showObject(Main BoxToShow, String BoxInfo){
        System.out.println("Box      " + BoxInfo);
        System.out.println("Type     " + BoxToShow.CerealType);
        System.out.println("Calories " + BoxToShow.Calories);
        System.out.println("Weight   " + BoxToShow.Weight);
        System.out.println("---------------------------------------" );
    }
}
 

[Rob Mech]

Ok, I think I figured this out. On return of an object from serialization the constructor is NOT run and thus won't increment the static variable.

Bugger!!!

[Keith Lynn]

Right. The whole point of serialization is to store the current state of the object. Rerunning the constructor on the object would defeat the purpose.

If you modify your example by having Main extend Main1, and then creating the file Main1.java

public class Main1 {
 
   public Main1() {
      System.out.println("Main 1");
   }
 
}

,

you will see that for the three instances of Main that you read back in, something is happening.

[Rob Mech]

Right. The whole point of serialization is to store the current state of the object. Rerunning the constructor on the object would defeat the purpose.

Exactly. I read that in the book too. What I think is great is that these sort of exercises help to reinforce the process. I answered my own question, it just had to click in.

[Pankaj Patel]

I think, if the Class doesnot implement Serializable interface then at the deserialization time, the constructor will be invoked. Here class Main implements Serializable so no need to invoke constructor at the deserialization time.

--------------
Modified Code : to Explain When and when not Constructor will be invoked.
--------------

  package SCJP;
 
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
 
public class SCJPChild extends SCJPParent implements Serializable 
{
String strChildName = "";
public SCJPChild(String strChildName)
{
this.strChildName = strChildName;
}

public static void main(String... args)
{
try
{
SCJPChild child1 = new SCJPChild("SCJP Child 1");
SCJPChild child2 = new SCJPChild("SCJP Child 2");
SCJPChild child3 = new SCJPChild("SCJP Child 3");
System.out.println("SCJP Child Name : "+child1.strChildName+" and Parent Variable : "+iParentVariable);
System.out.println("SCJP Child Name : "+child2.strChildName+" and Parent Variable : "+iParentVariable);
System.out.println("SCJP Child Name : "+child3.strChildName+" and Parent Variable : "+iParentVariable);

//Write Object
FileOutputStream fos;
        try 
        {
            fos = new FileOutputStream("d:\\public\\testSer.ser");
            ObjectOutputStream os = new ObjectOutputStream(fos);
            os.writeObject(child1);
            os.writeObject(child2);
            os.writeObject(child3);
            os.close();
            fos.close();
        }
        catch (Exception ex) 
        {
            ex.printStackTrace();
        }
        
        //Read Object
        FileInputStream fis;
        try 
        {
            fis = new FileInputStream("d:\\public\\testSer.ser");
            ObjectInputStream is = new ObjectInputStream(fis);
            child1 = (SCJPChild)is.readObject();
            child2 = (SCJPChild)is.readObject();
            child3 = (SCJPChild)is.readObject();
            is.close();
            fis.close();
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        
        System.out.println("SCJP Child Name : "+child1.strChildName+" and Parent Variable : "+iParentVariable);
System.out.println("SCJP Child Name : "+child2.strChildName+" and Parent Variable : "+iParentVariable);
System.out.println("SCJP Child Name : "+child3.strChildName+" and Parent Variable : "+iParentVariable);
}
catch(Exception e)
{
e.printStackTrace();
}
}
public void writeObject()
{

}
public void readObject()
{

}
}
 

class SCJPParent //implements Serializable 
{
static int iParentVariable = 0;
public SCJPParent()
{
iParentVariable ++;
}
}  

Try to avoid run this and see output and after that remove comment of SCJPParent Class and then run the code.

I hope this will help you little.