What are the differences between Externalizable and Serializable interfaces?

Question

Accepted Answer

Serializable and Externalizable are interfaces used for object serialization in Java, but they differ in the level of control they provide over the serialization process. Serializable relies on Java's built-in serialization mechanism, while Externalizable gives developers complete control over what data is written and read by explicitly implementing serialization logic.

Key Points:
• Serializable performs automatic serialization of eligible fields, requiring minimal coding effort.
• Externalizable requires implementation of writeExternal() and readExternal(), allowing precise control over the serialization and deserialization process.
• Externalizable can improve performance and reduce serialized data size by selectively serializing only required fields, but it increases implementation complexity.

Example:
Consider a User object containing sensitive information and temporary data. With Serializable, Java automatically serializes all non-transient fields. With Externalizable, you can choose exactly which fields to persist and how they should be restored.

Code Example:
```
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class User implements Externalizable {

private String name;
    private int age;

public User() {
        // Mandatory public no-arg constructor
    }

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

@Override
    public void writeExternal(
```
            ObjectOutput out)
```
            throws IOException {

out.writeObject(name);
        out.writeInt(age);
    }

@Override
    public void readExternal(
```
            ObjectInput in)
            throws IOException,
```
                   ClassNotFoundException {

name = (String) in.readObject();
        age = in.readInt();
    }
}
```
Interview Tip:
A concise interview answer is: Serializable uses Java's default serialization mechanism and requires little code, whereas Externalizable provides complete control over serialization through writeExternal() and readExternal() methods. Externalizable offers greater flexibility and optimization opportunities but requires more manual implementation effort.