1. import java.io.Serializable;
   
2. 
   
3. //这个类必须是实现了可序列化接口的
   
4. public class Fruit implements Serializable{
   
5.         //自定义一个固定的序列化版本号
   
6.         public static final long serialVersionUID = 30L;
   
7.         private String apple;
   
8.         private String orange;
   
9.         private String watermelon;
   
10.         private static String banana;
    
11.         //constructor
    
12.         public Fruit(String apple,String orange,String watermelon,String banana){
    
13.                 this.apple = apple;
    
14.                 this.orange = orange;
    
15.                 this.watermelon = watermelon;
    
16.                 this.banana = banana;
    
17.         }
    
18.         public String getBanana() {
    
19.                 return banana;
    
20.         }
    
21.         public void setBanana(String banana) {
    
22.                 this.banana = banana;
    
23.         }
    
24.         //setter and getter
    
25.         public String getApple() {
    
26.                 return apple;
    
27.         }
    
28.         public void setApple(String apple) {
    
29.                 this.apple = apple;
    
30.         }
    
31.         public String getOrange() {
    
32.                 return orange;
    
33.         }
    
34.         public void setOrange(String orange) {
    
35.                 this.orange = orange;
    
36.         }
    
37.         public String getWatermelon() {
    
38.                 return watermelon;
    
39.         }
    
40.         public void setWatermelon(String watermelon) {
    
41.                 this.watermelon = watermelon;
    
42.         }
    
43. }
    

复制代码

在这个类中我设置了一个静态属性banana，理论上静态存在于方法区内，序列化只能序列化堆内存中的对象，按理说banana是不能被序列化的。可是
下面代码：

1. import java.io.File;
   
2. import java.io.FileInputStream;
   
3. import java.io.FileNotFoundException;
   
4. import java.io.FileOutputStream;
   
5. import java.io.IOException;
   
6. import java.io.ObjectInputStream;
   
7. import java.io.ObjectOutputStream;
   
8. 
   
9. /**
   
10. * 示例：目的是对堆内存中的对象进行持久化存储
    
11. *     因为是对对象进行操作，所以咱们采用对象流
    
12. *     源和目标都是文件，所以对象流包装文件输入输出流
    
13. * @author lt
    
14. */
    
15. public class ObjectStreamDemo {
    
16.         //序列化方法
    
17.         public static void toSerial(Object obj,File saveFile) throws FileNotFoundException,IOException{
    
18.                 ObjectOutputStream oos = null;
    
19.                 oos = new ObjectOutputStream(new FileOutputStream(saveFile));
    
20.                 oos.writeObject(obj);
    
21.                
    
22.         }
    
23.         //反序列化方法
    
24.         public static Object fromSerial(File saveFile) throws FileNotFoundException,IOException, ClassNotFoundException{
    
25.                 ObjectInputStream ois = null;
    
26.                 ois = new ObjectInputStream(new FileInputStream(saveFile));
    
27.                 Object getObj = ois.readObject();
    
28.                 return getObj;
    
29.         }
    
30.         public static void main(String[] args) {
    
31.                 Fruit fruit = new Fruit("苹果","橘子","西瓜","香蕉");
    
32.                 File file = new File("d://serial.txt");
    
33.                 if(file.exists()){
    
34.                         try {
    
35. //                                toSerial(fruit,file);
    
36.                                 Fruit getFruit = (Fruit)fromSerial(file);
    
37.                                 System.out.println(getFruit.getApple() + "---" +
    
38.                                                            getFruit.getOrange() + "---" +
    
39.                                                            getFruit.getWatermelon() + "---" +
    
40.                                                            getFruit.getBanana());
    
41.                         } catch (FileNotFoundException e) {
    
42.                                 System.out.println("无法再当前路径下创建文件！");
    
43.                         } catch (IOException e) {
    
44.                                 System.out.println("对象流操作的文件不存在！");
    
45.                         } catch (ClassNotFoundException e) {
    
46.                                 System.out.println("序列化文件未找到！");
    
47.                         }                        
    
48.                 }else{
    
49.                         try {
    
50.                                 file.createNewFile();
    
51.                         } catch (IOException e) {
    
52.                                 System.out.println("serial.txt创建失败！");
    
53.                         }
    
54.                 }
    
55.         }
    
56. }

复制代码

运行结果： 苹果---橘子---西瓜---香蕉，香蕉也打印出来了，说明序列化成功了，这是为什么呢？？

静态成员是无法被序列化，它随着类的加载而存在于静态方法去中，先于对象的存在而存在，所以在调用的时候是可以显示出来的，但是并不是因为它被序列化了。

楼主你好，如果问题已解决请将帖子状态修改为提问结束，如果未解决请继续提问，谢谢合作
如果不会修改请看解释帖：http://bbs.itheima.com/thread-89313-1-1.html