如果在Serializable接口中使用Java，Java是否会自动使类可序列化？

Question

Let's say I have a Serializable interface as follows

public interface SomeInterface extends Serializable {

     public SomeClass getSomething(String someParameter);

}

Will SomeClass be Serializable automatically? To our surprise, our RMI application runs fine even when SomeClass does not implement Serializable.

Why is this?

Answer 1

Will SomeClass be Serializable automatically? To our surprise, our RMI application runs fine even when SomeClass does not implement Serializable .

No.

Serialization is about serializing the (non-transient) state of an object. The presence of a getSomething in the signature of some method doesn't require the state of your instance of a SomeInterface to include a SomeClass instance.

The method could be implemented to return a newly created SomeClass , the value of a transient field, the result of calling a static method on some other class, or .... null .

Answer 2

No, Any class just referenced within a class that is serializable is not serializable by default.

Ideally java should throw NotSerializableException , but since you are not getting the exception means, SomeClass extends Serializable by it's parent hierarchy somewhere.

Answer 3

No, SomeClass will not be Serializable just because this interface extends Serializable .

Serializable applies to the state of the object, there isn't anything here to imply that SomeClass is part of the state of SomeInterface. https://docs.oracle.com/javase/7/docs/api/java/io/Serializable.html

Are you sue that when SomeClass is being Deserialized it doesn't extend a class that implements Serializable ?

Answer 4

Suppose an implementation of SomeInterface just does something similar to

public class SomeInterfaceImpl implements SomeInterface {

    @Override
    public SomeClass getSomething(String someParameter) {
        return new SomeClass(someParameter);
    }
}

Why should your program fail on serializing objects of SomeInterfaceImpl when objects of SomeClass are just created on the fly ?

Minimal Example

Main.java

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Main {

    public static void main(String[] args) {

        try (final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                final ObjectOutputStream out = new ObjectOutputStream(byteArrayOutputStream)) {
            final SomeInterfaceImpl someInterfaceImpl = new SomeInterfaceImpl();
            final SomeClass something1 = someInterfaceImpl.getSomething("Test");
            out.writeObject(someInterfaceImpl);

            try (final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
                    final ObjectInputStream in = new ObjectInputStream(byteArrayInputStream)) {
                final SomeInterface someInterface = (SomeInterface) in.readObject();
                final SomeClass something2 = someInterface.getSomething("Test");

                final String someParameter1 = something1.getSomeParameter();
                System.out.println(someParameter1);

                final String someParameter2 = something2.getSomeParameter();
                System.out.println(someParameter2);
            } catch (ClassNotFoundException ex) {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            }
        } catch (IOException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}