Question

我已经定义了两个分类，如下所示

public class D{

    private String name;

    public D(){
        System.out.println("class D : constructor called !!");
    }

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }
}

public class E extends D implements Serializable{

    private String name;

    public E(){
        System.out.println("class E : constructor called !!");
    }

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }
}

在进行序列化时，它按预期工作，代码相同： -

public class TestSerialization{

    private static final String FILE_NAME = "E.ser";

    public static void main(String[] args){

        E e = new E();
        e.setName("New Name added");
        writeObject(e);
        E finalE = readObject();
        System.out.println(finalE.getName());

    }

    private static E readObject(){
        E e = null;
        try{
            FileInputStream fis = new FileInputStream(FILE_NAME);
            ObjectInputStream inputStream = new ObjectInputStream(fis);
            e =(E)inputStream.readObject();
            inputStream.close();
        }catch (FileNotFoundException ex){
            System.out.println("Exception : "+ex.getMessage());
        }catch (IOException ex){
            System.out.println("Exception : "+ex.getMessage());
        }catch (ClassNotFoundException ex){
            System.out.println("Exception : "+ex.getMessage());
        }
        return e;
    }

    private static void writeObject(E e){
        try{
            FileOutputStream fos = new FileOutputStream(FILE_NAME);
            ObjectOutputStream outputStream = new ObjectOutputStream(fos);
            outputStream.writeObject(e);
            outputStream.flush();
            outputStream.close();
        }catch (FileNotFoundException ex){
            System.out.println("Exception : "+ex.getMessage());
        }catch (IOException ex){
            System.out.println("Exception : "+ex.getMessage());
        }
    }
}

在序列化期间，构造函数链接正确： - 输出

class D : constructor called !!
class E : constructor called !!

但在反序列化过程中有点令人困惑： - 输出

class D : constructor called !!
class E : constructor called !!
class D : constructor called !!

为什么再次调用D类构造函数？

Answer 1

During Serialization Constructor chaining is coming correct :- Output

class D : constructor called !!
class E : constructor called !!

我认为你很困惑或误解了这个概念

如果您将主要类中的代码更改为

public static void main(String[] args){

    E e = new E();
    e.setName("New Name added");

    System.out.println("Serialization Started");
    writeObject(e);

    System.out.println("Deserialization Started");
    E finalE = readObject();
    System.out.println(finalE.getName());

}

您的输出将为

class D : constructor called !!
class E : constructor called !!
Serialization Started
Deserialization Started
class D : constructor called !!
New Name added

所以你可以在这里看到E和D的构造函数在序列化时没有调用，但在创建对象e时会调用它。

在对象的反序列化时，它的构造函数不会被调用，但会调用其父对象的默认构造函数。

因此必须有一个没有所有父类参数的标准构造函数，否则会抛出异常java.io.InvalidClassException

Answer 2

您正在重复计算构造E时打印的两条消息。这不是反序列化的一部分。

在deserilization中，Parent类（未实现Serialization接口）构造函数被调用两次

2 个答案: