对象序列化的代码，老师说静态是不能被序列化的。。。。。看我下面代码和结果

1. /*
   
2. 需求：将一个对象序列号，并从硬盘中读取序列化的对象
   
3. */
   
4. 
   
5. import java.io.*;
   
6. //创建Peason类，实现Serializable接口
   
7. class Peason implements Serializable
   
8. {
   
9.         //自定义serialVersionUID版本号
   
10.         public final static long serialVersionUID=32L;
    
11.         
    
12.         private String name;
    
13.         private int age;
    
14.         transient String id;//使用transient关键字表示该成员不被序列化
    
15.         static String country="CN";//静态成员不能序列化??????
    
16.         
    
17.         //构造函数
    
18.         Peason(String name,int age,String id,String country)
    
19.         {
    
20.                 this.name=name;
    
21.                 this.age=age;
    
22.                 this.id=id;
    
23.                 this.country=country;
    
24.         }
    
25.         //复写toString方法
    
26.         public String toString()
    
27.         {
    
28.                 return name+":"+age+":"+id+":"+country;        
    
29.         }
    
30. }
    
31. 
    
32. //序列化测试类
    
33. class ObjectStreamDemo
    
34. {
    
35.         public static void main(String[] args)
    
36.         {
    
37.                 //指定文件
    
38.                 File file =new File("obj.txt");
    
39.                 Peason p=new Peason("zhangsan",63,"shenma","USA");
    
40. 
    
41.                 //序列化指定对象
    
42.                 writeObj(p,file);
    
43. 
    
44.                 //反序列化
    
45.                 readObj(file);
    
46.                
    
47.         }
    
48. 
    
49.         //将指定对象序列化到指定文件中
    
50.         public static void writeObj(Peason p,File file)
    
51.         {
    
52.                 ObjectOutputStream oos=null;
    
53.                 try
    
54.                 {        
    
55.                         //创建写入流对象，关流文件
    
56.                         oos=new ObjectOutputStream(new FileOutputStream(file));
    
57.                         oos.writeObject(p);//写入对象数据
    
58.                 }
    
59.                 catch (IOException e)
    
60.                 {
    
61.                         throw new RuntimeException("对象写入失败");
    
62.                 }
    
63.                 finally
    
64.                 {
    
65.                         try
    
66.                         {
    
67.                                 if(oos!=null)
    
68.                                         oos.close();
    
69.                         }
    
70.                         catch (IOException e)
    
71.                         {
    
72.                                 throw new RuntimeException("关流失败");
    
73.                         }
    
74.                 }
    
75.         }
    
76. 
    
77.         //读取指定文件中的对象，也称反序列化
    
78.         public static void readObj(File file)
    
79.         {
    
80.                 ObjectInputStream ois=null;
    
81.                 try
    
82.                 {
    
83.                         //创建读取流对象，关联文件
    
84.                         ois =new ObjectInputStream(new FileInputStream(file));
    
85.                         //读取文件中的对象
    
86.                         Peason p=(Peason)ois.readObject();
    
87.                         System.out.println(p);
    
88.                 }
    
89.                 catch (Exception e)
    
90.                 {
    
91.                         throw new RuntimeException("文件读取对象失败");
    
92.                 }
    
93.                 finally
    
94.                 {
    
95.                         try
    
96.                         {
    
97.                                 if(ois!=null)
    
98.                                         ois.close();
    
99.                         }
    
100.                         catch (IOException e)
     
101.                         {
     
102.                                 throw new RuntimeException("关流失败");
     
103.                         }
     
104.                 }
     
105.         }
     
106. }
     

复制代码

怎么静态的country值改变了？？？
是我把两类写在一个文件中的问题？还是？？？？？？

尹桥印 发表于 2013-6-20 21:50
不懂哒。等楼下大神回答

我觉得你就是大神了{:3_53:}

尹桥印 发表于 2013-6-20 21:54
勿取笑~~

呀，尹兄变斑竹了，啥时候的事，不散点金币来庆祝下么

静态的不可以被序列化，静态的变量在方法区中，序列化的只能用于对象，对象在堆内存中。所以它们在两个地方，静态变量的值是null。

金辉 发表于 2013-6-20 22:09
静态的不可以被序列化，静态的变量在方法区中，序列化的只能用于对象，对象在堆内存中。所以它们在两个地方 ...

country是静态的CN，
但我在构造对象时修改为了USA
序列化后，读取出来变成了USA了
不知道咋整的

首先告诉你，确实没有被实例化：
然后修改对象后，直接反序列化。


获取结果为：






        // 读取文件中的对象
                        Person p = (Person) ois.readObject();

                        System.out.println(p);



你在这个地方直接将对象打印了。那么static 修饰的成员会被所有对象共享，实际上static修饰的成员是在静态区中。所以将对象的属性打印出来了

Super_Class 发表于 2013-6-20 22:49
首先告诉你，确实没有被实例化：
然后修改对象后，直接反序列化。

如果
想象老师视频中讲的一样，不被反序列化该怎么做？？:handshake

神之梦 发表于 2013-6-20 22:56
如果
想象老师视频中讲的一样，不被反序列化该怎么做？？

改序列号就可以了

刚开始是因为序列化没结束，内存中静态成员在方法区中，这时程序没有结束，接着进行了反序列化，文件中读不到静态的，但内存中的还没释放，所以会出想这种情况。
把序列化和反序列化分别运行就好了