反序列化会重新调用构造器吗？普通类和 record 为什么不同

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serial;
import java.io.Serializable;

/** Deserializes only byte arrays produced inside this program. */
public class SerializationConstructorsDemo {
    private static int checks;

    static class Base {
        static int constructors;
        int baseValue = 7;
        protected Base() { constructors++; }
    }

    static final class Ordinary extends Base implements Serializable {
        @Serial private static final long serialVersionUID = 1L;
        static int constructors;
        int amount;
        transient int initialized = 99;
        Ordinary(int amount) {
            if (amount < 0) throw new IllegalArgumentException("negative amount");
            constructors++;
            this.amount = amount;
        }
    }

    static final class Guarded implements Serializable {
        @Serial private static final long serialVersionUID = 1L;
        int amount;
        Guarded(int amount) {
            if (amount < 0) throw new IllegalArgumentException("negative amount");
            this.amount = amount;
        }
        @Serial private void readObject(ObjectInputStream input) throws IOException, ClassNotFoundException {
            input.defaultReadObject();
            if (amount < 0) throw new InvalidObjectException("negative amount");
        }
    }

    record Amount(int value) implements Serializable {
        static int constructors;
        Amount {
            if (value < 0) throw new IllegalArgumentException("negative amount");
            constructors++;
        }
    }

    private static byte[] encode(Serializable value) throws IOException {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        try (ObjectOutputStream output = new ObjectOutputStream(bytes)) { output.writeObject(value); }
        return bytes.toByteArray();
    }

    private static Object decodeOwnBytes(byte[] bytes) throws IOException, ClassNotFoundException {
        try (ObjectInputStream input = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
            return input.readObject();
        }
    }

    private static void check(boolean condition, String message) {
        if (!condition) throw new AssertionError(message);
        checks++;
    }

    public static void main(String[] args) throws Exception {
        Ordinary original = new Ordinary(5);
        // Deliberately break our own mutable test object before serializing it.
        original.amount = -5;
        original.baseValue = 88;
        Ordinary restored = (Ordinary) decodeOwnBytes(encode(original));
        check(Base.constructors == 2, "non-serializable base constructor runs again");
        check(Ordinary.constructors == 1, "ordinary serializable constructor is not rerun");
        check(restored.amount == -5, "constructor-only validation was not applied");
        check(restored.initialized == 0, "serializable field initializer was not rerun");
        check(restored.baseValue == 7, "base state rebuilt rather than restored from stream");
        System.out.println("ordinary: child_constructors=1; base_constructors=2; amount=-5; transient_initializer=0; base_value=7");

        Guarded guarded = new Guarded(5);
        guarded.amount = -5;
        boolean rejected = false;
        try { decodeOwnBytes(encode(guarded)); }
        catch (InvalidObjectException expected) { rejected = expected.getMessage().equals("negative amount"); }
        check(rejected, "readObject must validate restored fields");
        System.out.println("guarded: invalid_local_state=InvalidObjectException");

        Amount amount = new Amount(5);
        Amount copied = (Amount) decodeOwnBytes(encode(amount));
        check(copied.equals(amount) && copied != amount, "record round trip produces equal new value");
        check(Amount.constructors == 2, "record canonical constructor runs on restoration");
        System.out.println("record: canonical_constructors=2; value=5; same_reference=false");
        System.out.println("PASS checks=" + checks + "; input=program_generated_byte_arrays_only");
    }
}