Overview

Serialization in Java 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 is particularly important for sending objects over the network, saving them to a file, or caching objects in memory.

Key Concepts

1. Serializable Interface: A marker interface in Java that objects must implement to be serialized and deserialized.
2. ObjectOutputStream and ObjectInputStream: Java classes used for serialization and deserialization.
3. transient Keyword: Used to indicate that a field should not be serialized.

Common Interview Questions

Basic Level

1. What is the purpose of the Serializable interface in Java?
2. How do you serialize and deserialize an object in Java?

Intermediate Level

3. How can you customize serialization in Java?

Advanced Level

4. How do you handle serialization of objects with inheritance?

Detailed Answers

1. What is the purpose of the Serializable interface in Java?

Answer: The Serializable interface in Java serves as a marker interface to indicate that a class can be serialized. This interface does not contain any methods or fields and acts solely to signal the serialization mechanism that the class is eligible for serialization.

Key Points:
- Marker Interface: It's used to mark Java classes so that objects of these classes may be converted into a byte stream.
- Enables Object's State Preservation: Facilitates the saving of an object's state to a file or transferring it over a network.
- Implicit Behavior: Simply implementing this interface enables serialization without the need for additional methods.

Example:

import java.io.Serializable;

// Implementing Serializable interface
public class User implements Serializable {
    private String name;
    private transient int age; // transient field will not be serialized

    // Constructor, getters, and setters
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getters and Setters
    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;
    }
}

2. How do you serialize and deserialize an object in Java?

Answer: Serialization in Java is accomplished using ObjectOutputStream, and deserialization is done with ObjectInputStream. These streams are used to write and read objects to and from a byte stream, respectively.

Key Points:
- Use of ObjectOutputStream for serialization.
- Use of ObjectInputStream for deserialization.
- Handling IOException and ClassNotFoundException during the process.

Example:

import java.io.*;

public class SerializationExample {
    public static void serializeObject(User user) {
        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("user.ser"))) {
            out.writeObject(user);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static User deserializeObject() {
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("user.ser"))) {
            return (User) in.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) {
        User user = new User("John Doe", 30);
        serializeObject(user); // Serialize the object

        User deserializedUser = deserializeObject(); // Deserialize the object
        if (deserializedUser != null) {
            System.out.println("Name: " + deserializedUser.getName());
            // Note: Age is not printed because it was marked transient
        }
    }
}

3. How can you customize serialization in Java?

Answer: Customization of serialization in Java can be achieved by implementing the writeObject and readObject methods in your class. These methods allow you to control exactly how an object's fields are serialized and deserialized.

Key Points:
- Custom serialization logic with private void writeObject(ObjectOutputStream out) and private void readObject(ObjectInputStream in).
- Ensuring proper handling of transient fields if needed.
- Use of defaultWriteObject and defaultReadObject for default serialization behavior alongside custom logic.

Example:

import java.io.*;

public class CustomSerializationExample implements Serializable {
    private transient String sensitiveData;
    private String normalData;

    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject(); // Perform default serialization for normal fields
        out.writeObject(AES.encrypt(sensitiveData)); // Encrypt sensitive data before serialization
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject(); // Perform default deserialization for normal fields
        sensitiveData = AES.decrypt((String) in.readObject()); // Decrypt sensitive data after deserialization
    }

    // Constructors, getters, and setters omitted for brevity
}

4. How do you handle serialization of objects with inheritance?

Answer: When dealing with inheritance, if a superclass is serializable, its subclasses are automatically serializable. However, if the superclass is not serializable, the subclass needs to handle the superclass fields explicitly during serialization.

Key Points:
- Serialization with Inheritance: Automatic if superclass is serializable.
- Handling Non-Serializable Superclass: Subclass must manually manage the serialization of the superclass's fields.
- Use of transient for non-serializable parent objects and custom handling in writeObject and readObject.

Example:

import java.io.*;

class NonSerializableSuperclass {
    private String superData;

    // Constructor, getters, and setters
    public NonSerializableSuperclass(String superData) {
        this.superData = superData;
    }

    // Getters and Setters
    public String getSuperData() {
        return superData;
    }

    public void setSuperData(String superData) {
        this.superData = superData;
    }
}

public class SerializableSubclass extends NonSerializableSuperclass implements Serializable {
    private String subData;

    public SerializableSubclass(String superData, String subData) {
        super(superData);
        this.subData = subData;
    }

    // Custom serialization logic
    private void writeObject(ObjectOutputStream out) throws IOException {
        out.writeObject(getSuperData()); // Manually serialize superclass field
        out.defaultWriteObject();
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        setSuperData((String) in.readObject()); // Manually deserialize superclass field
        in.defaultReadObject();
    }

    // Getters and Setters for subData
    public String getSubData() {
        return subData;
    }

    public void setSubData(String subData) {
        this.subData = subData;
    }
}

This guide covers the basics to advanced concepts of serialization and deserialization in Java, with practical examples to help prepare for interviews on this topic.