Serializable and the no-args constructor - java help on CodeGym

1.) Why does this program work without the no-args constructor? I read somewhere that if you write readObject and writeObject methods in a descendant class, you need a no-args constructor in the parent class. Elsewhere I read that if you want to serialize a (serializable) class whose parent is not serializable, then the parent must have a no-arguments constructor. The way the shared program works proves that neither statement is true. Ultimately then, what is the correct statement, in what cases is a no-args constructor required? Because sometimes you really need it, prg won't work without it. But unfortunately I could not come to any conclusion when it is needed and when it is not. 2.) The output of the shared prg is this: A1, A2, B1, B2 null, null, B1, B2 Question: why does it not load the nameA1 and nameA2 fields of the object? Thanks in advance!:)

import java.io.*;

public class Solution  {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream arrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(arrayOutputStream);

        B b1 = new B();
        b1.nameA1="A1";
        b1.nameA2="A2";
        b1.nameB1="B1";
        b1.nameB2="B2";
        System.out.println(b1.nameA1 + ", " + b1.nameA2+", " + b1.nameB1+", " + b1.nameB2);

        oos.writeObject(b1);

        ByteArrayInputStream arrayInputStream = new ByteArrayInputStream(arrayOutputStream.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(arrayInputStream);

        B b2 = (B) ois.readObject();
        System.out.println(b2.nameA1 + ", " + b2.nameA2+", " + b2.nameB1+", " + b2.nameB2);
    }

    public static class A {

        public String nameA1;
        public String nameA2;

    //   public A() {
    //    }

    }

    public static class B extends A implements Serializable {

        public String nameB1;
        public String nameB2;

        private void writeObject(ObjectOutputStream out) throws IOException {
            out.defaultWriteObject();
        }

        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
        }

    }
}

// I made A and B regular classes class A { public String nameA1; public String nameA2; public A (String s) {} private A() {} // make this public, package private or protected to be able to serialize B } class B extends A implements Serializable { public String nameB1; public String nameB2; public B() { super(""); } @Serial private void writeObject(ObjectOutputStream out) throws IOException { out.defaultWriteObject(); out.writeObject(nameA1); out.writeObject(nameA2); } @Serial private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); nameA1 = (String) in.readObject(); nameA2 = (String) in.readObject(); } }

Comments (4)

Popular
New
Old

You must be signed in to leave a comment

Lisa

Level 41

22 December 2021, 13:47

useful

Friend Varga, nice to see you again around, hihih... hii I may have some hints to help you. 1. If you want to serialize a class, then it needs to implement the Serializable (Externalizable) interface (we will not consider some inner class tricks here). So if the supertype has none of these interfaces implemented you can not serialize them (directly). 2. If the supertype has no accessible no-args constructor, deserialization of the subtype will fail with an InvalidClassException. So you need to remove the (from the subtype accessible) no args consructor 3. You can use readObject, writeObject (or readExternal, writeExternal) to serialize additional elements. That way you can save and load the supertypes fields (if they are somehow accessible from the subtype). As usual some code. I modified your inner classes A and B so delete yours and add them below your class definition (make A and B regular, non inner classes). At first deserialization will fail cause there is no accessible no-args constructor in the first non-serializable supertype. Make it accessible and all works like a charm (hihi, I hope 😜🤪)

Gellert Varga

Level 23 , Szekesfehervar, Hungary

22 December 2021, 21:44

Thank you for your answers! And the code. I tried it:) Last night, a few minutes after I switched off the computer, I realized that my question-1 was partly stupid... Because in my shared code above, the default constructor is invisible but still there in class A. But if I would have written an argument constructor in class A, the default would have become unavailable and I would have already gotten the Exception on deserialization. Am I interpreting the followings correctly? I hope so:) 1) Fully automatic serialization (including the defaultRead(Write)Object method) cannot see/handle variables inherited from a non-serializable parent. That's why I got some nulls on deserialization yesterday. 2) Is it only necessary to have a no-args constructor in the parent class if the parent is not serializable? And if the parent is also serializable, then it doesn't need to have a no-args constructor. And one more question: What does the @Serial annotation mean? Something similar to @Override ? What is its role, meaning?

23 December 2021, 08:53

1 + 2. Yes, as said, you need to mark all classes you want to serialize with one of the two interfaces. Fields of not serializable classes are initialized during deserialization using the default (no-arg) constructor. That's why you need that in the parent class here (if the parent is serializable then construction of the object is done using reflection, but here the default constructor is called). Just implement the Serializable interface in the A class and remove the public no-args constructor - read- and writeObject methods would not be necessary anymore, too) 3. If you use the Externalizable interface you need the no-arg constructor always (totally different way of serialization). And yes, the @Serial annotation is similar to @Override (in newer Java versions). It tells the compiler to eg. check the syntax of the readObject, writeObject methods (and more, but you additionally need to set a compiler flag).

23 December 2021, 20:20

Thank you very much! Everything is clear now.:)