反序列化时，父类（未实现序列化接口）构造函数被调用两次

Question

I have defined two classed as shown below

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;
    }
}

While doing the Serialization it is working as expected, code for the same is :-

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());
        }
    }
}   

During Serialization Constructor chaining is coming correct :- Output

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

but during deserialization it is bit confusing:- Output

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

Why class D constructor is called again ?

Answer 1

During Serialization Constructor chaining is coming correct :- Output

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

I think you are confused or have misunderstood the concept

If you change your code in main class as

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());

}

Your output will be as

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

So you can see here Constructor of E and D are not called at the time of serialization but it is called while you are creating object e.

While deserialization of your object, its constructors doesn't called, but default constructor of its parent will be called.

So it is mandatory to have a standard constructor without parameters of all the parent class or else it will throw exception java.io.InvalidClassException

Answer 2

You are double-counting the two messages that are printed when you construct the E . That's not part of deserialization.