java - Cómo funciona la serialización cuando solo la subclase se implementa como serializable

inheritance serialization

Question

Solo la subclase ha implementado una interfaz Serializable .

import java.io.*;

public class NewClass1{

    private int i;
    NewClass1(){
    i=10;
    }
    int getVal() {
        return i;
    }
    void setVal(int i) {
        this.i=i;
    }
}

class MyClass extends NewClass1 implements Serializable{

    private String s;
    private NewClass1 n;

    MyClass(String s) {
        this.s = s;
        setVal(20);
    }

    public String toString() {
        return s + " " + getVal();
    }

    public static void main(String args[]) {
        MyClass m = new MyClass("Serial");
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("serial.txt"));
            oos.writeObject(m); //writing current state
            oos.flush();
            oos.close();
            System.out.print(m); // display current state object value
        } catch (IOException e) {
            System.out.print(e);
        }
        try {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("serial.txt"));
            MyClass o = (MyClass) ois.readObject(); // reading saved object
            ois.close();
            System.out.print(o); // display saved object state
        } catch (Exception e) {
            System.out.print(e);
        }
    }
}

Una cosa que noté aquí es que la clase padre no está serializada. Entonces, ¿por qué no lanzó la NotSerializableException

Salida

Serial 20
Serial 10

Además, la salida difiere de la Serialization y De-serialization . Solo lo sé, es porque la clase padre no ha implementado Serializable . Pero, si alguien me explica, qué sucede durante la serialización y des-serialización de objetos. ¿Cómo cambia el valor? No puedo entender, también he usado comentarios en mi programa. Entonces, si me equivoco en algún momento, por favor hágamelo saber.

Answer 1

De acuerdo con el javadoc serializable.

Durante la deserialización, los campos de las clases no serializables se inicializarán utilizando el constructor público o protegido sin argumentos de la clase. Un constructor sin argumentos debe ser accesible para la subclase que se puede serializar. Los campos de las subclases serializables serán restaurados desde el flujo.

Además, la excepción de serialización solo se lanza si la clase que se serializa no es serializable. tener padres no serializables está bien (siempre que tengan un constructor sin argumentos). El objeto en sí no es serializable, y todo lo extiende. la cita anterior también explica por qué obtiene diferentes valores para el campo de valor: se establece el constructor sin argumentos para la clase principal, que establece el campo de valor en 10, el campo pertenece al principal (no serializable), por lo que su valor no es escrito a / leído de la secuencia.

Answer 2

No lo he probado, pero obtendrá una NotSerializableException si serializa la instancia de la clase base. Es lo mismo cuando su clase contiene algunos miembros que no son Serializable .

Significa si creas un objeto NewClass1 nc1 = new NewClass1(); e intente serializar el obj nc1, obtendrá la excepción que desee.

Answer 3

Si su MyClass contiene referencias a un objeto de una clase no serializable, obtendrá una excepción NotSerializable en el tiempo de ejecución. Para probar, modifique MyClass para que contenga una referencia a un objeto de NewClass1. Si vuelves a correr te lanzará una excepción.

La deserialización consiste esencialmente en crear una instancia de una clase serializable y restaurar sus propiedades. Durante este proceso no se llama al constructor de la clase serializable. Más bien, se llama al constructor no arg de la primera súper clase no serializable.

En su caso, el constructor no arg de NewClass1 asigna 10 a su variable de instancia i. Entonces, durante la deserialización está imprimiendo 10 en lugar de 20.