Clarification on concepts for Serialization

[meera kanekal]

I just want to clarify some concepts on Serialization. These are my own examples based on K&B
Scenario 1:

    
Class Animal {}
Class Dog implements Serializable {
  Animal a ;
}

In this case when Dog is serialized and deserialized the code will compile fine but will get a runtime exception because A is not serializable.

Scenario 2:

 
 Class Animal{} 
 Class Dog implements Serializble {
   private transient Animal a ;
   // code for serialization and deserialization
 } 
 

In this case we get NullPointerException because the Animal object comes
back as null after the Dog is deserialized. When you deserialize the Dog the Dog constructor will not run but the Animal constructor will and so gets default values. But that is not the state of the Animal Dog used . Is that why Animal is null?

Scenario 3:

    
Class Animal{} 
 Class Dog implements Serializble {
   private transient Animal a ;
   // code for serialization and deserialization with code including the defaultWriteObject() and defaultReadObject() and handling Animal part of the code ourselves
 } 

We are ok here.

Scenario 4: involves inheritance

    
Class Animal{
  int numberOfLegs = 0;
  String eat;
  Animal(String e){
    eat = e;
    System.out.println(“In Animal”);
  }
} 
 


Class Dog extends Animal implements Serializble {
   private transient Animal a ;
   String name;
  Dog(int n, String s) {
      super(“dogFood”);
      numberOfLegs = n;
      name = s;
  }
code for serialization and deserialization
}

Here if the Dog object has been given values as
Dog d = new Dog(4, “Pete”);
Here the Dog constructor does not run when Dog is deserialized but the animal constructor will. bSo the numberOfLegs will be reset to 0 but the name of the dog is still Pete. But what about the call to super()?
I know this is a long question but I appreciate your input very much,

Thanks,
Meera

[James Tharakan]

Scenario 2:

When you deserialize the Dog the Dog constructor will not run but the Animal constructor will and so gets default values.

In this case there is NO relationship that is "IS-A"(extends). So there is no point of construtor calling.
the null value is because of the trasisent keyword

Scenario 4

but the name of the dog is still Pete.

Dog class is serializable...So pete(name) is restored.

But what about the call to super()?

super call will ONLY be executed if th DOG construtor is executed.

Correct me if i dont make sense.

[Deepesh Deomurari]

Scenario 1: Every Member object should implement Serializble .

Scenario 2: Every member object initialized by null automatically as part of object and class construction.

Scenario 4: If Dog constructor is not running in deserialization process then HOW that method call will run?

so super(“dogFood”); will never run. REMEMBER transient variables got reset at deserialization process. So constructor of Animal will be called but DOG implements Serializble so constructor of DOG will not be called.

[Deepesh Deomurari]

Scenario 1: Every Member object should implement Serializable .

Scenario 2: Every member object initialized by null automatically as part of object and class construction.

Scenario 4: If Dog constructor is not running in deserialization process then HOW that method call will run?

so super(“dogFood”); will never run. REMEMBER transient variables got reset at deserialization process. So constructor of Animal will be called but DOG implements Serializable so constructor of DOG will not be called.

[meera kanekal]

Well here there is a call to super constructor from Dog's constructor

    
Dog(int n, String s) {
      super(“dogFood”);
      numberOfLegs = n;
      name = s;
  }

So when Dog is deserialized it's constructor will not run but the Animal class's constructor will. I guess in this case Animal's instance variables will become set to their default values even though you use defaultWriteObject() and defaultReadObject() for Dog. Anyone else have an opinion?(Ankit, Punit, Ruben etc..?)

Thanks,
Meera

[Punit Singh]

  import java.io.*;

class Animal1{  
	  int numberOfLegs = 0;  
	  String eat;  
	  Animal1(String e){  
	    eat = e;  
	    System.out.println("In Animal");  
	  }  
	  Animal1(){
		//  eat="Animal Food";
	  }
	}   

public class Dog1 extends Animal1 implements Serializable {  
	   private transient Animal1 a ;  
	   String name;  
	  Dog1(int n, String s) {  
	      super("dogFood");  
	      numberOfLegs = n;  
	      name = s;  
	  }  
	  
	  
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		Dog1 d=new Dog1(5,"tommy");
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("dog.txt"));
		oos.writeObject(d);

		ObjectInputStream ois=new ObjectInputStream(new FileInputStream("dog.txt"));
		d=(Dog1)ois.readObject();

		System.out.println("Dog name: "+d.name);
		System.out.println("Dog numberOfLegs: "+d.numberOfLegs);
		System.out.println("Dog eat: "+d.eat);
	}  
	
	private void writeObject(ObjectOutputStream os) {
		try {
			os.writeInt(super.numberOfLegs); // 3
			os.writeObject(super.eat); // 3
			os.defaultWriteObject(); // 2
		} catch (Exception e) { e.printStackTrace(); }
	}
	private void readObject(ObjectInputStream is) {
		try {
			super.numberOfLegs=is.readInt();
			super.eat=(String)is.readObject();			
			is.defaultReadObject(); // 5
		} catch (Exception e) { e.printStackTrace(); }
	}
} 
  

Try this one.

[Ruben Soto]

Sorry to resurrect this zombie, but I think it might be worth doing so in this case. I modified Punit's code a little bit:

import java.io.*;

class Animal1{
          int numberOfLegs = 10;
          String eat;
          Animal1(String e){
            eat = e;
            System.out.println("In Animal");
          }
          Animal1(){
                //  eat="Animal Food";
          }
        }

public class Dog1 extends Animal1 implements Serializable {
           private transient Animal1 a ;
           String name;
          Dog1(int n, String s) {
              super("dogFood");
              numberOfLegs = n;
              name = s;
          }

        public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
                Dog1 d=new Dog1(5,"tommy");
                ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("dog.txt"));
                oos.writeObject(d);

                ObjectInputStream ois=new ObjectInputStream(new FileInputStream("dog.txt"));
                d=(Dog1)ois.readObject();

                System.out.println("Dog name: "+d.name);
                System.out.println("Dog numberOfLegs: "+d.numberOfLegs);
                System.out.println("Dog eat: "+d.eat);
        }

        private void writeObject(ObjectOutputStream os) {
                try {
                        //os.writeInt(super.numberOfLegs); // 3
                        //os.writeObject(super.eat); // 3
                        os.defaultWriteObject(); // 2
                } catch (Exception e) { e.printStackTrace(); }
        }
        private void readObject(ObjectInputStream is) {
                try {
                        //super.numberOfLegs=is.readInt();
                        //super.eat=(String)is.readObject();
                        is.defaultReadObject(); // 5
                } catch (Exception e) { e.printStackTrace(); }
        }
}

Output is:
In Animal
Dog name: tommy
Dog numberOfLegs: 10
Dog eat: null

It seems that when you implement readObject(), when deserialization takes place, the first thing that runs is the non-serializable superclass' initialization code. The calls to readInt and readObject are just overwriting the values set by that initialization code.

[meera kanekal]

So it means that the Animal part of Dog is reset but the Dog's variable -- name is not. Thank you both Punit and Ruben for clarifying this concept.
Regards,
Meera