Interfaz externalizable en Java

La externalización cumple el propósito de la serialización personalizada, donde podemos decidir qué almacenar en flujo.
La interfaz externalizable presente en java.io se utiliza para la externalización que amplía la interfaz serializable. Consiste en dos métodos que tenemos que anular para escribir/leer objetos en/desde el flujo, que son: 
 

// to read object from stream
void readExternal(ObjectInput in) 

// to write object into stream
void writeExternal(ObjectOutput out) 

Diferencias clave entre serializable y externalizable 
 

• Implementación: a diferencia de la interfaz Serializable que serializará las variables en el objeto con solo implementar la interfaz, aquí tenemos que mencionar explícitamente qué campos o variables desea serializar.
• Métodos: Serializable es una interfaz de marcador sin ningún método. La interfaz externalizable contiene dos métodos: writeExternal() y readExternal().
• Proceso: el proceso de serialización predeterminado tendrá lugar para las clases que implementan la interfaz serializable. El programador definió el proceso de serialización para las clases que implementan la interfaz externalizable.
• Compatibilidad con versiones anteriores y control: si tiene que admitir varias versiones, puede tener un control total con la interfaz externalizable. Puede admitir diferentes versiones de su objeto. Si implementa Externalizable, es su responsabilidad serializar la superclase.
• Constructor público sin argumentos: Serializable utiliza la reflexión para construir el objeto y no requiere ningún constructor de argumentos. Pero Externalizable requiere un constructor público sin argumentos.

A continuación se muestra el ejemplo de externalización:
 

// Java program to demonstrate working of Externalization
// interface
import java.io.*;
class Car implements Externalizable {
    static int age;
    String name;
    int year;
 
    public Car()
    {
        System.out.println("Default Constructor called");
    }
 
    Car(String n, int y)
    {
        this.name = n;
        this.year = y;
        age = 10;
    }
 
    @Override
    public void writeExternal(ObjectOutput out)
        throws IOException
    {
        out.writeObject(name);
        out.writeInt(age);
        out.writeInt(year);
    }
 
    @Override
    public void readExternal(ObjectInput in)
        throws IOException, ClassNotFoundException
    {
        name = (String)in.readObject();
        year = in.readInt();
        age = in.readInt();
    }
 
    @Override public String toString()
    {
        return ("Name: " + name + "\n"
                + "Year: " + year + "\n"
                + "Age: " + age);
    }
}
 
public class ExternExample {
    public static void main(String[] args)
    {
        Car car = new Car("Shubham", 1995);
        Car newcar = null;
 
        // Serialize the car
        try {
            FileOutputStream fo
                = new FileOutputStream("gfg.txt");
            ObjectOutputStream so
                = new ObjectOutputStream(fo);
            so.writeObject(car);
            so.flush();
        }
        catch (Exception e) {
            System.out.println(e);
        }
 
        // Deserialization the car
        try {
            FileInputStream fi
                = new FileInputStream("gfg.txt");
            ObjectInputStream si
                = new ObjectInputStream(fi);
            newcar = (Car)si.readObject();
        }
        catch (Exception e) {
            System.out.println(e);
        }
 
        System.out.println("The original car is:\n" + car);
        System.out.println("The new car is:\n" + newcar);
    }
}

Producción: 
 

Default Constructor called
The original car is:
Name: Shubham
Year: 1995
Age: 10
The new car is:
Name: Shubham
Year: 1995
Age: 10

En el ejemplo, la clase Car tiene dos métodos: writeExternal y readExternal. Entonces, cuando escribimos el objeto «Car» en OutputStream, se llama al método writeExternal para conservar los datos. Lo mismo se aplica al método readExternal. 
Cuando se reconstruye un objeto Externalizable, primero se crea una instancia usando el constructor público sin argumentos, luego se llama al método readExternal. Por lo tanto, es obligatorio proporcionar un constructor sin argumentos. 
Cuando un objeto implementa la interfaz Serializable, se serializa o se deserializa, no se llama al constructor del objeto y, por lo tanto, no se puede realizar ninguna inicialización que se implemente en el constructor. 

Este artículo es una contribución de Shubham Juneja . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.