首先是Externalizable的基本用法
Externalizable接口继承Serializable接口，而且在其基础上增加了两个方法：writeExternal()和readExternal()。这两个方法会在序列化和反序列化还原的过程中被自动调用，以便执行一些特殊的操作。

import java.io.ObjectOutput;
import java.io.ObjectInput;


public interface Externalizable extends java.io.Serializable {
   
    void writeExternal(ObjectOutput out) throws IOException;

    void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}

接下来是如何完整的保存和恢复一个Externalizable对象

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Blip implements Externalizable {
    private int i ;
    private String s;//没有初始化 
    public Blip() {
         //默认构造函数必须有，而且必须是public
        System.out.println("Blip默认构造函数");
    }
    public Blip(String s ,int i) {
        //s,i只是在带参数的构造函数中进行初始化。
        System.out.println("Blip带参数构造函数");
        this.s = s;
        this.i = i;
    }
    public String toString() {
        return s  + i ;
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        System.out.println("调用readExternal（）方法");
        s = (String)in.readObject();//在反序列化时，需要初始化s和i，否则只是调用默认构造函数，得不到s和i的值
        i = in.readInt();
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        System.out.println("调用writeExternal（）方法");
        out.writeObject(s); //如果不将s和i的值写入的话，那么在反序列化的时候，就不会得到这些值。
        out.writeInt(i);
    }

}

进行测试

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        System.out.println("序列化之前");
        Blip b = new Blip("This String is " , 47);
        System.out.println(b);
        
        System.out.println("序列化操作，writeObject");
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(out);
        oos.writeObject(b);
        System.out.println("反序列化之后,readObject");
        ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(in);
        Blip bb = (Blip)ois.readObject();
        System.out.println(bb);     
    }
}

输出的结果为

序列化之前
Blip带参数构造函数
This String is 47
序列化操作，writeObject
调用writeExternal（）方法
反序列化之后,readObject
Blip默认构造函数
调用readExternal（）方法
This String is 47

两者的区别
1、Serializable序列化时不会调用默认的构造器，而Externalizable序列化时会调用默认构造器

2、Serializable：一个对象想要被序列化，那么它的类就要实现 此接口，这个对象的所有属性（包括private属性、包括其引用的对象）都可以被序列化和反序列化来保存、传递。
Externalizable：他是Serializable接口的子类，有时我们不希望序列化那么多，可以使用这个接口，这个接口的writeExternal()和readExternal()方法可以指定序列化哪些属性。