Problem with Object Desirialization

[Sudhanshu Gupta]

hi,
i was reading the serialization chapter of Head First Java where I read

If the object has a non-serializable class
somewhere up its inheritance tree, the
constructor for that non-serializable class
will run along with any constructors above
that (even if they're serializable).

To try this out, i wrote the following sample code.

import java.io.*;

class A implements Serializable
{
	public A()
	{
			System.out.println("A Constructed");
	}
}

class B extends A
{
	public B()
	{
			System.out.println("B Constructed");
	}
}

class C extends B implements Serializable
{
	private int c;
	
	public C()
	{
			System.out.println("C Constructed");
	}
	
	public void setC(int val)
	{
		c=val;
	}
	public int getC()
	{
		return c;
	}
	
}

public class SerializeDemo
{
	public static void main(String arg[])
	{
		C objC = new C();
		objC.setC(34);
		saveObject(objC);
		System.out.println("c = " + objC.getC());
	
	}
	
	public static void saveObject(Object obj)
	{
		try
		{
			FileOutputStream file = new FileOutputStream("testdata.ser");
			ObjectOutputStream out = new ObjectOutputStream(file);
			out.writeObject(obj);
			out.close();
		}
		catch(Exception ex)
		{
			System.out.println("Error: " + ex);
		}
	}
	
	public static Object loadObject()
	{
		Object obj = null;
		try
		{
			FileInputStream file = new FileInputStream("testdata.ser");
			ObjectInputStream in = new ObjectInputStream(file);
			obj = in.readObject();
			in.close();
			return obj;
		}
		catch(Exception ex)
		{
			System.out.println("Error: " + ex);
		}
		finally
		{
			return obj;
		}
	}
	
}

This code worked as expected. the output was

A Constructed
B Constructed
C Constructed
c=34



But the problem appeared in deserialization. I just replaced the main() method by

public static void main(String arg[])
	{
	
		C objC = (C)loadObject();
		System.out.println("c = " + objC.getC());
	}

now the output is
c=34

while constructors of B & C were supposed to be called.
Can anyone please explain what's wrong?

[Kate Terlecka]

During the deserialization a constructor is not called. Everything is ok with the example and your code as well.

[Rob Spoor]

Class A is serializable, and therefore through inheritance so is B. Remove that interface from class A and you'll see what you expect.

[Sudhanshu Gupta]

Thank you very much Rob & Kate.
I understood it. But one thing that still bothers me is
if through inheritence, B also becomes serializable as A is serializable,
how is it possible to have an inheritence tree where a class is not serializable
even if there is a serializable class up in the heirarchy as quoted

If the object has a non-serializable class
somewhere up its inheritance tree, the
constructor for that non-serializable class
will run along with any constructors above
that (even if they're serializable).

I hope i m not being stupid. Just a bit confused.
Thanks again for your help.

[Rob Spoor]

If class A is not serializable, then class C has three classes up in the hierarchy that are not serializable - B, A and Object.

At the moment there is only Object, and that has a parameter-less constructor, so no problem there.

[Sudhanshu Gupta]

Thank you very much Rob.
I got the point.

[Scott Bravo]

If the object has a non-serializable class
somewhere up its inheritance tree, the
constructor for that non-serializable class
will run along with any constructors above
that (even if they're serializable).

This means that if you serialize any object whose any of the non serializable parent (who do not implement the Serializable interface) then at time of deserializtion the constructors of non serializable parent will only run......
example

public class A {
	char i;
	public A() {
		System.out.println("from a");
		i='A';
	}

}


public class B extends A{
	public B() {
		super();
		System.out.println("from B");
		i='B';
	}

}

import java.io.Serializable;
 public class C extends B implements Serializable{
public C() {
	i='C';
	System.out.println("from C");
	}
}

public static void main(String[] args)throws IOException ,ClassNotFoundException
	{	C c=new C();
		System.out.println("Before Serialization i:"+c.i);
		FileOutputStream fs=new FileOutputStream("barvo.ser");
		ObjectOutputStream os=new ObjectOutputStream(fs);
		os.writeObject(c);
		os.close();
		
		
		FileInputStream fis =new FileInputStream("barvo.ser");
		ObjectInputStream is =new ObjectInputStream(fis);
		C hc=(C)is.readObject();
		System.out.println("After Serialization i:"+hc.i);
		is.close();
	}

This Code will gonna produce following output:

from a
from B
from C
Before Serialization i:C
from a
from B
After Serialization i:B

[Scott Bravo]

If the object has a non-serializable class
somewhere up its inheritance tree, the
constructor for that non-serializable class
will run along with any constructors above
that (even if they're serializable).

This means that if you serialize any object whose any of the non serializable parent (who do not implement the Serializable interface) then at time of deserializtion the constructors of non serializable parent will only run......
example

public class A {
	char i;
	public A() {
		System.out.println("from a");
		i='A';
	}

}


public class B extends A{
	public B() {
		super();
		System.out.println("from B");
		i='B';
	}

}

import java.io.Serializable;
 public class C extends B implements Serializable{
public C() {
	i='C';
	System.out.println("from C");
	}
}

public static void main(String[] args)throws IOException ,ClassNotFoundException
	{	C c=new C();
		System.out.println("Before Serialization i:"+c.i);
		FileOutputStream fs=new FileOutputStream("barvo.ser");
		ObjectOutputStream os=new ObjectOutputStream(fs);
		os.writeObject(c);
		os.close();
		
		
		FileInputStream fis =new FileInputStream("barvo.ser");
		ObjectInputStream is =new ObjectInputStream(fis);
		C hc=(C)is.readObject();
		System.out.println("After Serialization i:"+hc.i);
		is.close();
	}

This Code will gonna produce following output:

from a
from B
from C
Before Serialization i:C
from a
from B
After Serialization i:B

Note in this example if I also serialize "the class A and class B" or I ll serialize "only class A"..then the output would be

from a
from C
Before Serialization i:C
After Serialization i:C

so if you want to run the parent class constructors at the time of "deserialization" ...then do not implement "serializable" interface in parent classes