Object Serialization with Inheritance in Java

Prerequisite : – Serialization, Inheritance

Serialization is a mechanism of converting the state of an object into a byte stream. Deserialization is the reverse process where the byte stream is used to recreate the actual Java object in memory. This mechanism is used to persist the object.

There are some cases of Serialization with respect to inheritance :

    1. Case 1: If superclass is serializable then subclass is automatically serializable : If superclass is Serializable, then by default every subclass is serializable. Hence, even though subclass doesn’t implement Serializable interface( and if it’s superclass implements Serializable), then we can serialize subclass object.
      // Java program to demonstrate 
      // that if superclass is
      // serializable then subclass 
      // is automatically serializable
      
      import java.io.FileInputStream;
      import java.io.FileOutputStream;
      import java.io.ObjectInputStream;
      import java.io.ObjectOutputStream;
      import java.io.Serializable;
      
      // superclass A 
      // implementing Serializable interface
      class A implements Serializable
      {
      	int i;
      	
      	// parameterized constructor
      	public A(int i) 
      	{
      		this.i = i;
      	}
      	
      }
      
      // subclass B 
      // B class doesn't implement Serializable
      // interface.
      class B extends A
      {
      	int j;
      	
      	// parameterized constructor
      	public B(int i, int j) 
      	{
      		super(i);
      		this.j = j;
      	}
      }
      
      // Driver class
      public class Test
      {
      	public static void main(String[] args) 
      			throws Exception 
      	{
      		B b1 = new B(10,20);
      		
      		System.out.println("i = " + b1.i);
      		System.out.println("j = " + b1.j);
      		
      		/* Serializing B's(subclass) object */
      		
      		//Saving of object in a file
      		FileOutputStream fos = new FileOutputStream("abc.ser");
      		ObjectOutputStream oos = new ObjectOutputStream(fos);
      			
      		// Method for serialization of B's class object
      		oos.writeObject(b1);
      			
      		// closing streams
      		oos.close();
      		fos.close();
      			
      		System.out.println("Object has been serialized");
      		
      		/* De-Serializing B's(subclass) object */
      		
      		// Reading the object from a file
      		FileInputStream fis = new FileInputStream("abc.ser");
      		ObjectInputStream ois = new ObjectInputStream(fis);
      			
      		// Method for de-serialization of B's class object
      		B b2 = (B)ois.readObject();
      			
      		// closing streams
      		ois.close();
      		fis.close();
      			
      		System.out.println("Object has been deserialized");
      		
      		System.out.println("i = " + b2.i);
      		System.out.println("j = " + b2.j);
      	}
      }
      

      Output:

      i = 10
      j = 20
      Object has been serialized
      Object has been deserialized
      i = 10
      j = 20
      

      a

    2. If a superclass is not serializable then subclass can still be serialized : Even though superclass doesn’t implements Serializable interface, we can serialize subclass object if subclass itself implements Serializable interface. So we can say that to serialize subclass object, superclass need not to be serializable. But what happens with the instances of superclass during serialization in this case. The following procedure explain this.

      What happens when a class is serializable but its superclass is not ?



      • Serialization: At the time of serialization, if any instance variable is inheriting from non-serializable superclass, then JVM ignores original value of that instance variable and save default value to the file.
      • De- Serialization: At the time of de-serialization, if any non-serializable superclass is present, then JVM will execute instance control flow in the superclass. To execute instance control flow in a class, JVM will always invoke default(no-arg) constructor of that class. So every non-serializable superclass must necessarily contain default constructor, otherwise we will get runtime-exception.
      // Java program to demonstrate 
      // the case if superclass need
      // not to be serializable 
      // while serializing subclass 
      
      import java.io.FileInputStream;
      import java.io.FileOutputStream;
      import java.io.ObjectInputStream;
      import java.io.ObjectOutputStream;
      import java.io.Serializable;;
      
      // superclass A 
      // A class doesn't implement Serializable
      // interface.
      class A 
      {
      	int i;
      	
      	// parameterized constructor
      	public A(int i) 
      	{
      		this.i = i;
      	}
      	
      	// default constructor
      	// this constructor must be present
      	// otherwise we will get runtime exception
      	public A()
      	{
      		i = 50;
      		System.out.println("A's class constructor called");
      	}
      	
      }
      
      // subclass B 
      // implementing Serializable interface
      class B extends A implements Serializable
      {
      	int j;
      	
      	// parameterized constructor
      	public B(int i,int j) 
      	{
      		super(i);
      		this.j = j;
      	}
      }
      
      // Driver class
      public class Test
      {
      	public static void main(String[] args) 
      			throws Exception 
      	{
      		B b1 = new B(10,20);
      		
      		System.out.println("i = " + b1.i);
      		System.out.println("j = " + b1.j);
      		
      		// Serializing B's(subclass) object 
      		
      		//Saving of object in a file
      		FileOutputStream fos = new FileOutputStream("abc.ser");
      		ObjectOutputStream oos = new ObjectOutputStream(fos);
      			
      		// Method for serialization of B's class object
      		oos.writeObject(b1);
      			
      		// closing streams
      		oos.close();
      		fos.close();
      			
      		System.out.println("Object has been serialized");
      		
      		// De-Serializing B's(subclass) object 
      		
      		// Reading the object from a file
      		FileInputStream fis = new FileInputStream("abc.ser");
      		ObjectInputStream ois = new ObjectInputStream(fis);
      			
      		// Method for de-serialization of B's class object
      		B b2 = (B)ois.readObject();
      			
      		// closing streams
      		ois.close();
      		fis.close();
      			
      		System.out.println("Object has been deserialized");
      		
      		System.out.println("i = " + b2.i);
      		System.out.println("j = " + b2.j);
      	}
      }
      

      Output:

      i = 10
      j = 20
      Object has been serialized
      A's class constructor called
      Object has been deserialized
      i = 0
      j = 20
      

      b

    3. If the superclass is serializable but we don’t want the subclass to be serialized : There is no direct way to prevent subclass from serialization in java. One possible way by which a programmer can achieve this is by implementing the writeObject() and readObject() methods in the subclass and needs to throw NotSerializableException from these methods. These methods are executed during serialization and de-serialization respectively. By overriding these methods, we are just implementing our own custom serialization.
      // Java program to demonstrate 
      // how to prevent 
      // subclass from serialization
      
      import java.io.FileInputStream;
      import java.io.FileOutputStream;
      import java.io.IOException;
      import java.io.NotSerializableException;
      import java.io.ObjectInputStream;
      import java.io.ObjectOutputStream;
      import java.io.Serializable;
      
      // superclass A 
      // implementing Serializable interface
      class A implements Serializable
      {
      	int i;
      	
      	// parameterized constructor
      	public A(int i) 
      	{
      		this.i = i;
      	}
      	
      }
      
      // subclass B 
      // B class doesn't implement Serializable
      // interface.
      class B extends A
      {
      	int j;
      	
      	// parameterized constructor
      	public B(int i,int j) 
      	{
      		super(i);
      		this.j = j;
      	}
      	
      	// By implementing writeObject method, 
      	// we can prevent
      	// subclass from serialization
      	private void writeObject(ObjectOutputStream out) throws IOException
      	{
      		throw new NotSerializableException();
      	}
      	
      	// By implementing readObject method, 
      	// we can prevent
      	// subclass from de-serialization
      	private void readObject(ObjectInputStream in) throws IOException
      	{
      		throw new NotSerializableException();
      	}
      	
      }
      
      // Driver class
      public class Test
      {
      	public static void main(String[] args) 
      			throws Exception 
      	{
      		B b1 = new B(10, 20);
      		
      		System.out.println("i = " + b1.i);
      		System.out.println("j = " + b1.j);
      		
      		// Serializing B's(subclass) object 
      		
      		//Saving of object in a file
      		FileOutputStream fos = new FileOutputStream("abc.ser");
      		ObjectOutputStream oos = new ObjectOutputStream(fos);
      			
      		// Method for serialization of B's class object
      		oos.writeObject(b1);
      			
      		// closing streams
      		oos.close();
      		fos.close();
      			
      		System.out.println("Object has been serialized");
      		
      		// De-Serializing B's(subclass) object 
      		
      		// Reading the object from a file
      		FileInputStream fis = new FileInputStream("abc.ser");
      		ObjectInputStream ois = new ObjectInputStream(fis);
      			
      		// Method for de-serialization of B's class object
      		B b2 = (B)ois.readObject();
      			
      		// closing streams
      		ois.close();
      		fis.close();
      			
      		System.out.println("Object has been deserialized");
      		
      		System.out.println("i = " + b2.i);
      		System.out.println("j = " + b2.j);
      	}
      }
      

      Output:

      i = 10
      j = 20
      Exception in thread "main" java.io.NotSerializableException
      	at B.writeObject(Test.java:44)
      

This article is contributed by Gaurav Miglani. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.




Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.

Recommended Posts:



2.6 Average Difficulty : 2.6/5.0
Based on 3 vote(s)