Programs

Serializable Interface in Java with Examples 

Java offers several packages, of which the interface Serializable is one. It is present within the Java package java.io and is a type of marker interface. When defined as a marker interface, there are no methods or fields present in the interface. So, whenever any classes implement the interface, the interface is not required to implement any methods. The classes implement the interface if a class wants their instances to get serialized or get deserialized. 

The mechanism of serialization is used for the conversion of an object state into a stream of bytes. This mechanism is carried out by using the ObjectOutputStream. The process of deserialization is just the opposite of the process of serialization. In this case, the byte stream is converted back to the object of Java. ObjectInputStream is used for deserialization. 

Serialization 

The conversion of the state of any object into a stream of bytes is known as serialization. And the opposite of serialization is deserialization. An object of Java can be converted into a stream of static bytes. This static stream can then be saved on a database, or it can also get transferred to a different network. The process of serialization is instance-dependent. This means that the serialization of objects can be carried out on one platform, and then the deserialization of the objects can be carried out on another platform. A particular type of marker interface, “Serializable,” is implemented for the serialization process. So, the classes eligible for serialization, i.e., the serializable class in Java, should implement the marker interface. 

This mechanism of writing an object state into a stream of bytes is known as serialization. The mechanism is primarily used in JMS, EJB, JPA, RMI, and Hibernate technologies. 

ObjectInputStream and the ObjectOutputStream are the forms of high-level classes that extend the java.io.InputStream and the java.io.OutputStream. The primitive types and the object graphs can be written to the OutputStream by the ObjectOutputStream in a byte

stream. The stream that results from the conversion can be read through the ObjectInputStream. So, for the serialization, the method writeObject() is called from the ObjectOutputStream and for the deserialization, the method readObject() is called from the ObjectInputStream class. 

The method which is the most important in ObjectOutputStream is: 

The above line of code is taken from https://www.baeldung.com/java-serialization. 

In the above line of code, an object which is serializable is taken, and then it is converted into a stream or stream of bytes. 

In the case of ObjectInputStream, the most critical method is: 

The above line of code is taken from https://www.baeldung.com/java-serialization. 

The above line of code can read the sequence of bytes and convert this stream of bytes into an object of Java. The original object can be cast back through this. 

An illustration of the serialization process can be described below: 

A class “Person” is considered for serialization. The static fields are not serialized, and they belong to some classes. The class fields can be ignored by using the keyword “transient” in the process of serialization.

Source 

The object of the person type can be saved to some local file, and then the value is read back in. The below-shown code can be used for this purpose.

ObjectOutputStream was used for saving the object state into a file through using the FileOutputStream. In this example, a file named “yourfile.txt” has been created in the project’s directory. Through the use of FileInputStream, the created file is loaded. This stream is then picked up by the ObjectInputStream and gets converted into a new object with the name p2. The state of the object loaded up is finally tested, and it gets matched with the original object’s state. The object which is loaded has to be cast explicitly to the typical person. 

Caveats in Java serialization 

1. Inheritance and Composition 

Whenever a user implements the interface java.io.Serializable, all the class sub-classes that implement the interface become serializable. Also, if an object holds a reference to a different object, the objects referred to implement the interface are serializable separately; if these objects don’t implement the interface, then an exception will be thrown out. The exception thrown out will be NotSerializableException. Also, if suppose an array of objects is stored at a serializable object, all the array objects should be serialized. If no serialization of the objects happens, then it will throw the exception “NotSerializableException.”

2. Serial Version UID 

For every class that implements the Serializable interface, a number is associated with each of the classes. The number is associated with the Java Virtual Machine. This is mainly done to verify that the objects which are loaded and saved have the exact attributes. Only if the attributes are the same, the objects would be compatible upon serialization. IDE’s generate these numbers automatically and are mainly based on the names of the class, its attributes, and the access modifiers associated with it. An exception, “InvalidClassException,” will be thrown if a different number results from the changes.

If a serialVersionUID is not declared by a serializable class, the JVM will automatically generate it during the run time. Although there will be automatic generation of the number, it is still recommended that the classes declare a serialVersionUID. This is because the serialVersionUID, which will be automatically generated, will be dependent on the compiler and may sometimes throw unexpected InvalidClassExceptions. 

3. Custom serialization 

A default way has been set in Java for serializing the objects. Java can override this default behavior. There is a way for custom serialization. It is particularly useful in cases where the object having unserializable attributes is being tried to be serialized. The serialization for such objects can be done through two methods within a class the user wants to be serialized. These two methods are: 

The above two methods can be used to serialize the attributes into any forms that can be serialized, which were earlier unserializable. 

Advantages of serialization in Java 

One of the advantages of serialization in Java is that the state of an object can be traveled on a network. 

The Java interface java.io.Serializable 

java.io.Serializable is a marker interface which means that there are no methods and objects within the interface. The primary function of the marker interface is to mark the

classes of Java to give a particular capability to all the objects of the classes. Examples of marker interfaces are Remote and Cloneable. 

The interface must be implemented by any class which uses the interface for serializing its objects. By default, the classes such as wrapper classes and the String class implement the interface java.io.Serializable. 

A java serializable example is shown below. 

In the above code, it can be observed that the class Student implements the interface Serializable. Therefore once the class implements the interface Serializable, the objects within the class can be converted into bytes of stream. 

  • ObjectOutputStream class 

This class is used for writing the primitive types of data and the Java objects into the OutputStream. The object which supports the interface java.io.Serializable can be used for getting written into streams. 

  • ObjectInputStream class

All the primitive data that were written through using the ObjectOutputStream is deserialized by using the ObjectInputStream. 

An example of a Serializable interface in Java is shown below. 

In this example, the class Student is going to be serialized. The method writeObject() of the class ObjectOutputStream, provides all the functionality for serializing the objects. The state of the object is saved in a file with the name f.txt. 

 

Conclusions

The article discussed the concept of serialization in Java. It listed out the interfaces and the other important methods required for serializing the objects of a class. The process of serialization is always associated with an id or a number with every serializable class. This number is referred to as the SerialVersionUID. The main use of the SerialVersionUID is to verify the sender and the receiver for the object that is to be serialized. This is because both the sender and the receiver should be the same. 

It is an important feature of the programming language Java. If you want to know more about such important features and concepts in Java and master your programming language skills, you can check the Software Engineering Courses offered by upGrad. If you are a working professional, the course is best suited for you. For any form of queries, our team of assistance can be contacted. You can also browse our website for the specific course and get detailed information.

What is serializable interface in Java?

Serializable interface is a marker interface. The marker interface provides a hint to the Java runtime that the implementing class allows itself to be serialized. The runtime will take advantage of this interface to serialize the object. Serializable interface in java is a special interface to be implemented by data classes in java. When a class implements this interface, it can be persisted in a database. This interface is declared in java.io package. Serializable interface has two methods, readResolve() and writeReplace() , which are used to read and write object in database.

What happens if we implement Serializable interface in Java?

Implementing Serializable interface in Java means to have an object which can be serialized and de-serialized in any system having Serializable interface. The implementation of such interface would be effective when the class is being serialized externally by third party libraries (JSON, XML, etc.) or by network protocols. When a variable is declared as Serializable, then each instance of the variable will be serialized and deserialized if it is passed as a parameter to a method or when it is returned from a method. Serialization is performed programmatically so that the state of an object can be preserved for later, when it needs to be deserialized and presented to the user of the object.

Can we transfer a serialized object via network?

A serialized object is an object that contains a stream of bytes. The object's constructor or writeObject() / readObject() methods are used to place the stream of bytes into the object. The data stored may be text, audio, video, or any custom application data. The data for these objects may be stored in a file or on a remote server. To transfer serialized objects via network one must use RMI (Remote Method Invocation) protocol. RMI is a good protocol for creating distributed applications. It enables the client to communicate with methods on objects in a Java application running on a server. RMI protocol is a Remote Procedure Call ( RPC ) mechanism.

Want to share this article?

Prepare for a Career of the Future

Leave a comment

Your email address will not be published. Required fields are marked *

Leave a comment

Your email address will not be published. Required fields are marked *

×
Get Free career counselling from upGrad experts!
Book a session with an industry professional today!
No Thanks
Let's do it
Get Free career counselling from upGrad experts!
Book a Session with an industry professional today!
Let's do it
No Thanks