Сериализация динамически сгенерированного класса

Попробуйте реализовать writeReplace в вашем объекте Temp, чтобы он записал Base, и реализовать readResolve в вашем объекте Base, чтобы он создал Temp, который его обертывает. См. Сериализуемый контракт.

Код будет выглядеть примерно так. Обратите внимание, что я на самом деле не проверял это, но это должно быть довольно близко.

public class Base implements Serializable {
    // Existing members here

    private Object readResolve() throws ObjectStreamException {
        return new Temp(this);
    }
}

public class Temp implements Serializable {
    Base base;

    public Temp(Base base) {
        this.base = base;
    }

    // Other existing methods here

    private Object writeReplace() throws ObjectStreamException {
        return base;
    }
}

Я понимаю, что это вводит неприятную круговую зависимость между этими двумя классами, но я не вижу другого отличного способа сделать это, кроме внешнего метода чтения/записи, как предлагали другие. Преимущество этого подхода в том, что он поддерживает запись Temp как части более крупного графа объектов.

Ну, во-первых, Ричард, это действительно первый раз, когда я вижу этот необычный случай, спасибо, что рассказали о нем ;) Здесь я разработал способ решить вашу проблему. Я надеюсь, что это может быть полезно для вас.:

import java.io.*;
abstract class Base implements Serializable
{
    protected int x ;
    private static final long serialVersionUID = 1L;
    public Base(int x) { this.x = x; }
    public abstract void baseMethod();
}
class Temp implements Serializable
{
    private static final long serialVersionUID = 2L;//Make Temp serializable also.
    public Base getBase(int i) 
    {
        Base base = new Base(i)
        {
            static final long serialVersionUID = 1L;
            @Override
            public void baseMethod() { System.out.println(x); } 
        };
        return base;
    }
}
public class ReadWriteBaseObject 
{
    public static Base createBaseObject(int i)
    {
        Temp temp = new Temp();//You might be creating your Temp object here Dynamically..
        Base base = temp.getBase(i);
        return base;
    }
    public static Base read()
    {
        ObjectInputStream oin = null;
        try
        {
            FileInputStream fin = new FileInputStream("BASE.ser");
            oin = new ObjectInputStream(fin);
            Base base = (Base)oin.readObject();
            return base;
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
            return null;
        }
        finally
        {
            if (oin!=null)
            {
                try
                {
                    oin.close();
                }
                catch (Exception ex){}
            }
        }
    }
    public static void write(Base base)
    {
        if (base == null)
        {
            System.out.println("Can't write null");
            return;
        }
        ObjectOutputStream os = null;
        try
        {
            FileOutputStream fos = new FileOutputStream("BASE.ser");
            os = new ObjectOutputStream(fos);
            os.writeObject(base);
            System.out.println("Wrote to file");
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            if (os!=null)
            {
                try
                {
                    os.close();
                }
                catch (Exception ex){}
            }
        }
    }
    public static void main(String st[])
    {
        Base base = createBaseObject(45);
        write(base);
        Base obj = read();
        obj.baseMethod();
    }
}

EDIT
Хотя экземпляры анонимных классов могут быть успешно сериализованы, Java настоятельно не рекомендует это из-за некоторых сложностей. Здесь это то, что официальный сайт Java состояния:

Примечание. Сериализация внутренних классов (т. е. вложенных классов, которые не являются статическими классами-членами), включая локальные и анонимные классы, настоятельно не рекомендуется по нескольким причинам. Поскольку внутренние классы, объявленные в нестатических контекстах, содержат неявные непереходные ссылки на вмещающие экземпляры классов, сериализация такого экземпляра внутреннего класса также приведет к сериализации связанного с ним экземпляра внешнего класса. Синтетические поля, сгенерированные javac (или другими компиляторами JavaTM) для реализации внутренних классов, зависят от реализации и могут различаться между компиляторами; различия в таких полях могут нарушить совместимость, а также привести к конфликту
значений serialVersionUID по умолчанию. Имена, присвоенные локальным и анонимным внутренним классам, также зависят от реализации и могут отличаться в разных компиляторах. Поскольку внутренние классы не могут объявлять статические члены, отличные от постоянных полей времени компиляции, они не могут использовать механизм serialPersistentFields для обозначения сериализуемых полей. Наконец, поскольку внутренние классы, связанные с внешними экземплярами, не имеют конструкторов с нулевым аргументом (конструкторы таких внутренних классов неявно принимают охватывающий экземпляр в качестве предшествующего параметра), они не могут реализовать Externalizable. Однако ни одна из перечисленных выше проблем не относится к статическим классам-членам.

Чтобы узнать больше о сериализации в Java, посмотрите < сильно>здесь