Serializable Interface in Java

by

In Java, the Serializable interface in Java is a marker interface that indicates that a class can be serialized. Serialization is the process of converting an object’s state into a byte stream. Which can then be transmitted over a network or stored in a persistent storage medium such as a file. The byte stream can later be used to recreate the object in memory.

How to make Java class serializable?

To make a Java class serializable, the class must implement the Serializable interface. This interface does not have any methods that need to be implemented. It simply serves as a flag to indicate that the class can be serialized.

Example

Here is an example of a serializable class in Java:

import java.io.Serializable;

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Serialize the object

To serialize an object of this class, we can use the ObjectOutputStream class.

Following is an example of how to serialize an object and write it to a file:

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

Person person = new Person("John", 30);

try (FileOutputStream fos = new FileOutputStream("person.ser");
     ObjectOutputStream oos = new ObjectOutputStream(fos)) {
    oos.writeObject(person);
} catch (IOException e) {
    e.printStackTrace();
}

Deserialize the object

To deserialize the object, we can use the ObjectInputStream class.

We can see an example of how to read the serialized object from a file and recreate it in memory in the following code:

import java.io.FileInputStream;
import java.io.ObjectInputStream;

Person person;

try (FileInputStream fis = new FileInputStream("person.ser");
     ObjectInputStream ois = new ObjectInputStream(fis)) {
    person = (Person) ois.readObject();
} catch (IOException | ClassNotFoundException e) {
    e.printStackTrace();
}

It’s important to note that not all objects are serializable. For example, objects that contain references to non-serializable objects cannot be serialized. In these cases, we can use the transient keyword to exclude certain fields from the serialization process.

import java.io.Serializable;

public class Employee implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    private transient String password;  // exclude from serialization

    public Employee(String name, int age, String password) {
        this.name = name;
        this.age = age;
        this.password = password;
    }

    // getters and setters
}

Conclusion

The Serializable interface in Java is a powerful tool that allows us to easily serialize and deserialize objects. By implementing this interface and using the ObjectOutputStream and ObjectInputStream classes, we can easily store and retrieve objects from persistent storage or transmit them over a network. However, it’s important to note that not all objects are serializable and we may need to use the transient keyword to exclude certain fields from the serialization process.

Related Posts