Author: TheTechFinanceGuy

Serialization is the mechanism of converting the state of an object into a stream of bytes.

Deserialization is the exact opposite of that i.e; the byte stream is converted back to the object.

Why objects are serialized?

Sometimes it is important to capture the state of an object. For example in a mobile game if the game terminates abruptly and you reopen the game, it tells you to resume from where you let off. The point of resumption was may be maintained in an serialized object. When the game was restarted, the game programs de-serialized the object and got the resumption points.

Objects are serialized in memory or in a file. Since it is serialized as a stream of bytes, it is platform independent and can also be transmitted over the network.

This serialization of objects so so important.

Since the byte stream created is platform independent. So, the object serialized on one platform can be deserialized on a different platform.

How to make an Object serializable?

1)The object of the class which we want to serialize should implement the java.io.Serializable interface. It is an marker interface which means there is no method or member variables declared inside an interface. So the use of this interface is to mark that object or some special behavior which in our case is serialization.
2)Then to finally serialize the object in memory or in a file, we make use of the ObjectOutputStream class. The ObjectOutputStream class contains writeObject() method for serializing an Object. Kindly check below.

public final void writeObject(Object obj)
                       throws IOException

Similarly, the ObjectInputStream class contains readObject() method for deserializing an object.

public final Object readObject()
                  throws IOException,
               ClassNotFoundException

Which member are serialized?

When we try to serialize one object, the serialization process try to serialize all the fields (primitive and reference) with our class (except static and transient fields).

When a class implements the Serializable interface, all its sub classes become serializable as well. But when an object has a reference to another object, these objects must implement the Serializable interface separately. If our class is having even a single reference to a non Serializable class then JVM will throw NotSerializableException.

What is a serial version id?

It is an ID which is declared as a member variable inside a serializable class.

Suppose we have a class which is serialized to a file. Then there are some changes made to the class with one class variable removed. When we try to de-serialize the object, it would not serialize and additionally give an invalid class exception. Exception occurs because the class version has changed.

To resolve this, the Serialization runtime associates a version number with each Serializable class called a serial version id. So every object serialized of that class would have the same version number. So when that object is deserialized, it is successfully done and no exception occurs inspite of changes in the class structure.

A Serializable class can declare its own UID explicitly by declaring a field name.
It must be static, final and of type long.
It is declared as follows.

static final long serialVersionUID=70L;

What happens to the static and transient members?

As you read above, fields marked as static and transient are not serialized. So when de-serialization happens, transient fields are set as null(same applies for new fields which were added in class definition after object was serialized) and static field reads from JVM memory to get the latest value available there.

Let’s look at an example with the code.

import java.io.*; 
  
class SerialTest implements java.io.Serializable 
{ 
    //Member Variables
    private static final long serialversionUID = 
                                 149568898L;
    public String a; 
    public String b; 
  
    public SerialTest(String a, String b) 
    { 
        this.a = a; 
        this.b = b; 
    } 
  
} 
  
class MainTest 
{ 
    public static void main(String[] args) 
    {

        // Block for serialization 
    
        SerialTest ser = new SerialTest("James", "Gosling"); 
        String filename = "Serfile.ser"; 
          
        try
        {    
            FileOutputStream file = new FileOutputStream(filename); 
            ObjectOutputStream out = new ObjectOutputStream(file); 
              
            out.writeObject(ser); 
              
            out.close(); 
            file.close(); 
              
            System.out.println("Object has been serialized to a file"); 
  
        } 
          
        catch(IOException ex) 
        { 
            System.out.println("IOException occured"); 
        } 
  
  
        SerialTest ser2 = null; 
  
        // Block for Deserialization 
        try
        {    
            // Reading the object from a file 
            FileInputStream file = new FileInputStream(filename); 
            ObjectInputStream in = new ObjectInputStream(file); 
              
            ser2 = (SerialTest)in.readObject(); 
              
            in.close(); 
            file.close(); 
              
            System.out.println("Object has been deserialized from file"); 
            System.out.println("a = " + ser2.a); 
            System.out.println("b = " + ser2.b); 
        } 
          
        catch(IOException ex) 
        { 
            System.out.println("IOException occured while deserialization"); 
        } 
          
        catch(ClassNotFoundException ex) 
        { 
            System.out.println("ClassNotFoundException occured while deserialization"); 
        } 
  
    } 
} 

O/P:
Object has been serialized to file
Object has been deserialized from file
a = James
b = Gosling