Comment se fait-variable statique est Sérialisé?

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;  
    }  
}

Pouvez-vous s'il vous plaît dites-moi comment la variable statique est sérialisé ??

OriginalL'auteur Girish Nair | 2012-10-08

11

Apparemment, les variables statiques peuvent être sérialisés (Mais vous ne devriez pas le faire), depuis sérialisation est le processus de l'enregistrement de l'état d'un instance d'une classe, et les variables statiques sont communes à toutes les instances. Ils ne disent rien à propos de l'instance de l'état, donc, il ne serait pas logique du tout.

Supposons que vous avez été autorisé à sérialiser une variable statique. Ensuite, lorsque vous désérialisez l'instance, vous serez l'obtention d'une ancienne copie de cette variable, qui peut avoir été modifié depuis lors. Depuis la variable statique est partagée entre toutes les instances de la classe, d'un changement de la variable à partir de n'importe quelle instance doit être reflétée dans la présente instance.

Donc, ils ne devraient pas être sérialisé, parce que la variable en vertu de ces conditions pourrait violer son contrat comme une variable statique.

Sérialisation: -
- Ne devrait pas sérialiser les variables statiques..
Désérialisation: -
- Instance obtenir les champs statiques qui a été chargé avec la classe.. Donc, tout changement qui pourrait avoir été fait pour que la variable sera tenu pour responsable de cette instance aussi..
Cette réponse n'est pas correcte, la variable statique n'est pas d'être conservés et restaurés par la sérialisation. Les variables statiques ne peuvent pas et ne sont pas numérotés; la valeur du champ statique reste dans le champ de la classe tout le temps...il n'a jamais quitté la mémoire à tous.

OriginalL'auteur Rohit Jain
2

Le Courant de sortie de MySerializable Classe est au-dessous de
```
x : 8, y :9
x : 0, y :9
```
Dans ce cas, les variables statiques sont arriver imprimé après l'appel de méthode toString (), par ce temps, il lit la valeur de la classe de niveau variable.

Essayez ceci:

Ajouter cette ligne de code dans MySerializable Classe après //Serialize bloc
```
AnotherClass.y = 5;
```
la sortie est :
```
x : 8, y :9
x : 0, y :5
```
cela signifie que la variable statique est pas stocker dans le fichier, il va lire dynammically par la méthode toString ().

OriginalL'auteur NPKR
0

- Serialization est utilisé pour enregistrer les état de l'objet lors de la sérialisation, tant lors de la dé-sérialisation de l'état sauvegardé peut être utilisé dans le but de ressusciter un objet Identique sur le tas.

- Oui static variable peut être serialized mais il n'a pas de sens.....

OriginalL'auteur Kumar Vivek Mitra
0

Variables statiques ne peuvent pas être et ne sont pas numérotés.

Votre question semble être fondée sur le fait que vous voyez la même valeur de la variable statique après la sérialisation comme avant la sérialisation, mais cela n'est pas dû à la valeur sérialisée et restaurés.

Ce comportement est parce que l'initialiseur statique pour que la variable statique à 9, et il n'est jamais changé.

Pour vérifier que les variables statiques sont pas sérialisé, vous pouvez soit effectuer NPKR suggéré de changer, de modifier le champ statique entre la sérialisation et la désérialisation, ou vous pouvez faire ce qui suit:

Exécuter ce programme, puis commentez les bits qui effectue la sérialisation. Vous aurez l'ancienne version sérialisée sur le disque.

Puis changer l'initialiseur statique du champ statique de y = 5, et exécutez à nouveau le programme: vous obtiendrez de " x: 0 y: 5as the output, because the value9` du champ statique n'a pas été restauré.

OriginalL'auteur Theodore Murdock

Vous devez vous connecter pour publier un commentaire.