In Java, Serialization is the process of converting an object into a byte stream so it can be easily saved to a file, sent over a network, or stored in a database. Deserialization is the reverse process—reconstructing the object from the byte stream. These techniques are fundamental in distributed systems, persistence mechanisms, and remote method invocation (RMI). Java provides built-in support for serialization via the Serializable interface and related classes in the java.io package.

Serialization is the mechanism of converting the state of an object into a byte stream. This byte stream can then be persisted to a disk, transmitted to another JVM, or stored in a database.

• Saving object states to files
• Sending objects over a network (e.g., in sockets or RMI)
• Deep copying objects
• Caching in distributed applications

The simplest way to make a class serializable is to implement the java.io.Serializable marker interface.

import java.io.Serializable;
public class Student implements Serializable {
private int id;
private String name;
// Constructor, getters, setters...
}

Key Points:
• It’s a marker interface (no methods).
• All non-static and non-transient fields are serialized.
• If a class is serializable, all its parent classes must also be serializable.

Writing an Object to File

import java.io.*;
public class SerializeDemo {
public static void main(String[] args) throws Exception {
Student s = new Student(101, "Abraham");
FileOutputStream fos = new FileOutputStream("student.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(s);
oos.close();
fos.close();
System.out.println("Object has been serialized");
}
}

Deserialization is the process of converting a byte stream back into a copy of the original object.

Reading an Object from File

import java.io.*;
public class DeserializeDemo {
public static void main(String[] args) throws Exception {
FileInputStream fis = new FileInputStream("student.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
Student s = (Student) ois.readObject();
ois.close();
fis.close();
System.out.println("Deserialized Student: " + s.getName());
}
}

Fields declared with the transient keyword are not serialized.

class User implements Serializable {
String username;
transient String password; // Will not be saved in the byte stream
}

• Static fields are not serialized, as they belong to the class, not the instance.

class Example implements Serializable {
static int count = 0;
int id;
}

serialVersionUID is used for version control. It ensures that a serialized object matches the class definition during deserialization.

private static final long serialVersionUID = 1L;

If Not Defined:
• Java generates one at runtime.
• Incompatible changes to the class may cause InvalidClassException.

If a superclass is not serializable, its fields will not be serialized.

Example:

class Person {
String nationality = "Indian";
}
class Employee extends Person implements Serializable {
int id;
}

• On deserialization, nationality will not retain its state.

Use java.io.Externalizable for more control over serialization.
Methods to Implement:
• writeExternal(ObjectOutput out)
• readExternal(ObjectInput in)

Example:

class Employee implements Externalizable {
private String name;
private int salary;
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(name);
out.writeInt(salary);
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
name = (String) in.readObject();
salary = in.readInt();
}
}

Serialization automatically handles nested object references, as long as all referenced objects are also serializable.

class Address implements Serializable {
String city;
}
class Employee implements Serializable {
String name;
Address address; // Serialized if Address implements Serializable
}

• Always define serialVersionUID.
• Avoid serializing sensitive information.
• Use transient for fields that should not be serialized.
• Prefer Externalizable only when fine-grained control is needed.
• Keep the serialized form stable across versions when compatibility is required.

Serialization and Deserialization allow Java objects to be persisted or transmitted with ease. Using the Serializable interface, objects can be saved and restored automatically. More control is possible via the Externalizable interface. With careful management of fields (using transient, static, and serialVersionUID), developers can serialize complex object graphs reliably. This capability is particularly crucial in enterprise systems, remote communications, and large-scale data handling.