Question

我试图将一个对象放入一个文件，然后尝试使用Externalizable接口读取同一个对象，我得到一个Exception没有Car类的有效构造函数。

import java.io.*;
class Base
{
    int a;
}
class Car extends Base implements Externalizable
{
    static int b;
    String c="";

    Car(int d,int e,String f)
    {
        a=d;
        b=e;
        c=f;
    }
    Car()
{super();} 
        public void writeExternal(ObjectOutput oos)
        {
            try
            {
            oos.writeInt(a);
            oos.writeInt(b);
            oos.writeObject(c);
            }
            catch(Exception e){}
        }
        public void readExternal(ObjectInput ois)
        {
            try
            {
            a=ois.readInt();
            b=ois.readInt();
            c=(String)ois.readObject();
            }
            catch(Exception e){}
        }
    }
    class Main
    {
            public static void main(String args[])throws Exception
        {
            Car c1=new Car(1,2,"Manish");
            FileOutputStream fos=new FileOutputStream("man.txt");
            ObjectOutputStream oos=new ObjectOutputStream(fos);
            oos.writeObject(c1);
            FileInputStream fis=new FileInputStream("man.txt");
            ObjectInputStream ois=new ObjectInputStream(fis);
            Object o=ois.readObject();
            Car c2=(Car)o;
            System.out.println(c2.a+" "+c2.b+" "+c2.c);
        }
    }

有人可以解释错误是什么吗？

Answer 1

Java Serialization假定您有一个公共默认构造函数。

有些图书馆没有做出这样的假设，但内置的序列化确实如此。

除非你确定这样做是安全的，否则你不应该忽视异常。在你的情况下，你不需要抓住它们。

public void writeExternal(ObjectOutput oos) throws IOException {
    oos.writeInt(a);
    oos.writeInt(b);
    oos.writeObject(c);
}

Answer 2

主要问题是一个简单的事实：Externalization接口通过对象本身来提供序列化。

这意味着对象本身有责任保存和恢复其状态，这意味着必须存在一个对象才能反转自身内部的状态（通过readExternal）。

幕后发生的事情是序列化引擎分配对象的空实例然后在其上调用readExternal。

所以基本上会发生的事情是：

Car emptyCar = Car.class.newInstance();
emptyCar.readExternal(state);

由于这种情况发生在与Car不同的包中，并且Car()具有default可见性，因此引擎无法调用默认构造函数，因此错误。

您必须提供public默认构造函数。

java中的外化

2 个答案: