¿Cómo es que la variable estática está serializada?

Question

public class MySerializable implements Serializable{ 

    private int x=10; 
    private static int y = 15; 
    public static void main(String...args){ 
     AnotherClass a = new AnotherClass(); 
     AnotherClass b; 
     //Serialize 
     try { 
      FileOutputStream fout = new FileOutputStream("MyFile.ser"); 
      ObjectOutputStream Oout = new ObjectOutputStream(fout); 
      Oout.writeObject(a); 
      System.out.println(a.toString()); 
     } catch (FileNotFoundException e) { 
      e.printStackTrace(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 

     //De-serialize 
     try { 
      FileInputStream fis = new FileInputStream("MyFile.ser"); 
      ObjectInputStream Oin = new ObjectInputStream (fis); 
      b = (AnotherClass) Oin.readObject(); 
      System.out.println(b.toString()); 
     } catch (FileNotFoundException e) { 
      e.printStackTrace(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     }catch (ClassNotFoundException e){ 
      e.printStackTrace(); 
     } 

    } 
} 

class AnotherClass implements Serializable{ 

    transient int x = 8; 
    static int y = 9; 

    @Override 
    public String toString() { 
     return "x : " + x + ", y :" + y; 
    } 
} 

¿Puede decirme cómo se serializa la variable estática?

Answer 1

Al parecer, las variables estáticas se pueden serializar (Pero no se debe hacer eso), ya que serialización es el proceso de guardar el estado de un ejemplo de una clase, y las variables estáticas son comunes a todas las instancias . No dicen nada sobre el estado de la instancia, por lo tanto, no tendría ningún sentido.

Supongamos que se le permite serializar una variable estática. Luego, cuando deserialice la instancia, obtendrá una copia antigua de esa variable, que podría haber cambiado desde entonces. Dado que la variable estática se comparte en todas las instancias de la clase, un cambio en la variable de cualquier instancia debe reflejarse en esta instancia.

Por lo tanto, no deben ser serializados, ya que la variable en estas condiciones podría violar su contrato como una variable estática.

serialización: -

• no deben serializar las variables estáticas ..

Deserialización: -

• Instancia obtendrá los campos estáticos que se cargó con la clase ... Entonces, cualquier cambio que se haya hecho para esa variable será responsable de este caso también ..

Answer 2

-Serialization se utiliza para guardar el estado del objetodurante la serialización, por lo que durante la des-serialización el estado guardado se puede utilizar con el fin de resucitar a una Objeto idéntico en el montón.

-Sístatic variable puede ser serialized pero no tiene ningún sentido .....

Answer 3

la salida de corriente de MySerializable clase está por debajo

x : 8, y :9 
x : 0, y :9 

En En este caso, la variable estática se imprime después de llamar al método toString(), en este momento se leerá el valor del nivel de clase v Ariable.

Prueba esto:

Añadir esta línea de código en MySerializable clase después //Serialize bloque

AnotherClass.y = 5; 

la salida es:

x : 8, y :9 
x : 0, y :5 

Esto significa que la variable estática no está almacenando en el archivo, se leerá dinámicamente por el método toString().

Answer 4

Las variables estáticas no pueden ni se serializan.

Su pregunta parece basarse en el hecho de que está viendo el mismo valor de la variable estática después de la serialización que antes de la serialización, pero esto no se debe a que el valor se haya serializado y restaurado.

Este comportamiento se debe a que el inicializador estático para esa variable estática lo establece en 9 y nunca se cambia.

para verificar que las variables estáticas no son serializados, puede realizar el cambio sugerido por NPKR, modificando el campo estático entre la serialización y deserialización, o usted podría hacer lo siguiente:

Ejecutar este programa, a continuación, en comentario el bit que realiza la serialización. Como resultado, tendrá la versión serializada anterior en el disco.

Luego cambie el inicializador estático del campo estático a y = 5, y ejecute el programa de nuevo: obtendrá 'x: 0 y: 5 as the output, because the value 9` del campo estático no restaurado.

Answer 5

import java.io.FileInputStream; 
 
import java.io.FileNotFoundException; 
 
import java.io.FileOutputStream; 
 
import java.io.IOException; 
 
import java.io.ObjectInputStream; 
 
import java.io.ObjectOutputStream; 
 
import java.io.Serializable; 
 

 
class TestJava implements Serializable{ 
 
    public static int k = 10; 
 
    public int j=5; 
 
public static void main(String[] args) { 
 
    
 
    TestJava tj1= new TestJava(); 
 
    TestJava tj2; 
 
    
 
    
 
     try{ //serialization 
 
      FileOutputStream fos = new FileOutputStream("myclass.ser"); 
 
      ObjectOutputStream oos = new ObjectOutputStream(fos); 
 
      oos.writeObject(tj1); 
 
      oos.close(); 
 
      fos.close(); 
 
      System.out.println("object serielized 1..."+tj1.j); 
 
      System.out.println("object serielized 2..."+tj1.k); 
 
      System.out.println("object serielized 3..."+k); 
 
      k=++k; // 'k' value incrementd after serialization 
 
      } catch(FileNotFoundException fnfe){ 
 
      fnfe.printStackTrace(); 
 
      } catch(IOException ioex){ 
 
      ioex.printStackTrace(); 
 
      } 
 
    
 
     
 
      try{ //deserialization 
 
       FileInputStream fis = new FileInputStream("myclass.ser"); 
 
       ObjectInputStream ois = new ObjectInputStream(fis); 
 
       tj2 = (TestJava) ois.readObject(); 
 
       ois.close(); 
 
       fis.close(); 
 
       System.out.println("object DEEEEserielized 1..."+tj2.j); 
 
       System.out.println("object DEEEEserielized 2..."+tj2.k); 
 
       System.out.println("object DEEEEserielized 3..."+k); 
 
      // in deserialization 'k' value is shown as incremented. 
 
      // That means Static varialbe 'K' is not serialized. 
 
      // if 'K' value is serialized then, it has to show old value before incrementd the 'K' value. 
 
      } catch(FileNotFoundException fnfe){ 
 
       fnfe.printStackTrace(); 
 
      } catch(IOException ioex){ 
 
       ioex.printStackTrace(); 
 
      } catch(ClassNotFoundException CNFE){ 
 
       CNFE.printStackTrace();     
 
      } 
 
     } 
 
} 
 

 
/* Output of the above program 
 
    
 
object serielized 1...5 
 
object serielized 2...10 
 
object serielized 3...10 
 
object DEEEEserielized 1...5 
 
object DEEEEserielized 2...11 
 
object DEEEEserielized 3...11 
 

 

 
*/