如何使用超类构造函数创建子类的实例？

Question

显然，Java 序列化机制以某种方式设法使用超类构造函数创建子类的实例。我想知道，这怎么可能？

这是一个test，它证明了这一点：

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.text.MessageFormat;

public class Test {

    public static class A {
        public final int a;

        public A() {
            this.a = 0;
            System.out.println(
                    MessageFormat.format(
                        "new A() constructor is called to create an instance of {0}.",
                    getClass().getName()));
        }

        public A(int a) {
            this.a = a;
            System.out.println(
                    MessageFormat.format(
                        "new A(int) constructor is called to create an instance of {0}.", 
                    getClass().getName()));
        }
    }

    public static class B extends A implements Serializable {
        public final int b;

        public B(int a, int b) {
            super(a);
            this.b = b;
            System.out.println(
                    MessageFormat.format(
                        "new B(int, int) constructor is called to create an instance of {0}.",
                    getClass().getName()));
        }

        @Override
        public String toString() {
            return "B [a=" + a + ", b=" + b + "]";
        }


    }

    public static void main(String[] args) throws Exception {

        B b1 = new B(10,20);

        System.out.println(b1);

        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try(ObjectOutputStream oos = new ObjectOutputStream(bos)) {
            oos.writeObject(b1);
        }

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        try (ObjectInputStream ois = new ObjectInputStream(bis)) {
            B b2 = (B)ois.readObject();
            System.out.println(b2);
        }
    }
}

输出：

new A(int) constructor is called to create an instance of Test$B.
new B(int, int) constructor is called to create an instance of Test$B.
B [a=10, b=20]
new A() constructor is called to create an instance of Test$B.
B [a=0, b=20]

（你可以try it out live on Ideone）。

如您所见，在反序列化期间调用A() 构造函数以生成B 的实例。在后台，这是在ObjectStreamClass.newInstance() 中调用的，并且实例是由Constructor.newInstance() 调用创建的。在调试器中，构造函数cons为Test$A()：

在调试器中跳出，创建的对象最终从ObjectInputStream.readObject(...)返回，并毫无问题地转换为B。

所以如果我没记错的话，似乎是使用A() 构造函数（通过反射）来创建B 的实例。

我想知道这怎么可能。

Answer 1

我怀疑构造函数cons 一定有问题。而且我找到了A的普通构造函数改成B的serializable constructor的位置。

首先我查看了cons 的第一个设置位置。在序列化的情况下这是ObjectStreamClass的构造函数：

if (externalizable) {
   cons = getExternalizableConstructor(cl);
} else {
   cons = getSerializableConstructor(cl); //here
   ...

于是我翻了一遍，发现在ObjectStreamClass.getSerializableConstructor：

Constructor<?> cons = initCl.getDeclaredConstructor((Class<?>[]) null);
...
cons = reflFactory.newConstructorForSerialization(cl, cons); //this does change
cons.setAccessible(true);
return cons;

在cons.newInstance() 上设置调试监视

• 在标记线之前 => 类型是A。
• 在标记线之后 => 类型为B。

也就是说，用于序列化的构造函数不是A的普通构造函数，而是经过修改的用于序列化的构造函数，适配最终类。

Answer 2

反序列化期间的 JVM 不会调用被反序列化的类的构造函数。但是为了创建反序列化类的实例，它需要首先创建它的超类。所以 JVM 调用第一个父级的无参数构造函数，它没有实现Serializable。尽管它不会在此构造函数中创建您的类的实例。如果您的父类是Serializable，则根本没有构造函数调用。