黑马程序员技术交流社区

标题: 反序列化时静态变量为什么只有显示初始化 [打印本页]

---

作者: 倪杭乘    时间: 2012-5-11 13:18
标题: 反序列化时静态变量为什么只有显示初始化
ObjcetInputstream在反序列化ObjectOutputStream序列化对象的时候，如果存入的对象中有静态变量，为什么反序列化就变成默认初始化值了，想了解下详细过程

---

作者: 小小企鹅    时间: 2012-5-11 13:58
序列化就如同另外一个构造函数，只不过是有由stream进行创建的

---

作者: 袁冬梅    时间: 2012-5-11 14:43
好吧，这个是序列化的内容，首先理解序列化和反序列化是干什么的。
简单说就是为了保存在内存中的各种对象的状态，并且可以把保存的对象状态再读出来。
那么这里，所谓的内存是只那一块呢，这个内存是只的堆内存。所以，序列化的内容就是堆内存中的东西。
下面的图表示了，对象和对象中静态变量存储的位置，这样的话你应该知道为什么静态变量的值不能够被序列化了。

---

作者: 黄坚声    时间: 2012-5-11 16:00
Java提供了将对象以字节的形式写入到磁盘中，在需要的时候在从磁盘中恢复的功能，在网络传输中非常有用，下面将代码贴上，分别用两种形式实现了对象的序列化，其中第二种当时能将指定的变量序列化，更加人性化的随心所欲

   
[java] view plaincopyprint?
01.package com.bird.thinking;  
02.  
03.import java.io.FileInputStream;  
04.import java.io.FileOutputStream;  
05.import java.io.ObjectInputStream;  
06.import java.io.ObjectOutputStream;  
07.import java.io.Serializable;  
08./**
09. * @use 实现对对象的序列化和反序列化
10. * @author Bird
11. *
12. */  
13.public class Data {  
14.    public static void writeObject() throws Exception{  
15.        Worm worm = new Worm("Bird");  
16.        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("d://worm.out"));  
17.        out.writeObject(worm);  
18.        out.close();//关闭的同时也刷新清空了缓冲区   
19.    }  
20.      
21.      
22.    public static void readObject() throws Exception{  
23.        ObjectInputStream in = new ObjectInputStream(new FileInputStream("d://worm.out"));  
24.        Worm s2 = (Worm) in.readObject();  
25.        System.out.println(s2);  
26.    }  
27.      
28.    public static void main(String[] args) throws Exception{  
29.    //  writeObject();   
30.        readObject();  
31.    }  
32.}  
33.  
34.  
35.class Worm implements Serializable{  
36.      
37.    private static final long serialVersionUID = 1L;  
38.    private String name = null;  
39.    public Worm(String name){  
40.        this.name = name;  
41.    }  
42.      
43.    public String toString(){  
44.        return name;  
45.    }  
46.}  
package com.bird.thinking;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* @use 实现对对象的序列化和反序列化
* @author Bird
*
*/
public class Data {
        public static void writeObject() throws Exception{
                Worm worm = new Worm("Bird");
                ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("d://worm.out"));
                out.writeObject(worm);
                out.close();//关闭的同时也刷新清空了缓冲区
        }
       
       
        public static void readObject() throws Exception{
                ObjectInputStream in = new ObjectInputStream(new FileInputStream("d://worm.out"));
                Worm s2 = (Worm) in.readObject();
                System.out.println(s2);
        }
       
        public static void main(String[] args) throws Exception{
        //        writeObject();
                readObject();
        }
}


class Worm implements Serializable{
       
        private static final long serialVersionUID = 1L;
        private String name = null;
        public Worm(String name){
                this.name = name;
        }
       
        public String toString(){
                return name;
        }
}








下面是第二种方式




[java] view plaincopyprint?
01.package com.bird.thinking;  
02.  
03.import java.io.Externalizable;  
04.import java.io.FileInputStream;  
05.import java.io.FileNotFoundException;  
06.import java.io.FileOutputStream;  
07.import java.io.IOException;  
08.import java.io.ObjectInput;  
09.import java.io.ObjectInputStream;  
10.import java.io.ObjectOutput;  
11.import java.io.ObjectOutputStream;  
12./**
13. * @use 第二种可控制序列化变量个数的方式
14. * @author Bird
15. *
16. */  
17.public class Blip3 implements Externalizable {  
18.    private int i;  
19.    private String s;//没有实例化   
20.    public Blip3(){  
21.        System.out.println("Blip3 Constructor!!");  
22.    }  
23.    //注意  这里的s没有实例化   
24.      
25.    public Blip3(String x, int a){  
26.        System.out.println("Blip3(String x, int a)");  
27.        s = x;  
28.        i = a;  
29.        //s  和 i实例化在非默认构造函数中   
30.    }  
31.      
32.    public String toString(){  
33.        return s + i;  
34.    }  
35.      
36.    public void writeExternal(ObjectOutput out){//可选择写入变量   
37.        System.out.println("Blip3.writeExternal");  
38.        try {  
39.            out.writeObject(s);  
40.            out.writeInt(i);  
41.        } catch (IOException e) {  
42.            throw new RuntimeException(e);  
43.        }//必须进行这两项，否则就一个变量也不出初始化   
44.    }  
45.      
46.    public void readExternal(ObjectInput in){//可选择读入数据   
47.        System.out.println("Blip3.readExternal");  
48.        try {  
49.            s = (String)in.readObject();  
50.            i = in.readInt();  
51.        } catch (ClassNotFoundException e) {  
52.              
53.        } catch (IOException e) {  
54.        throw new RuntimeException(e);  
55.        }  
56.         
57.    }  
58.      
59.    public void read() throws FileNotFoundException, IOException, ClassNotFoundException{//读取序列化的类   
60.        ObjectInputStream in = new ObjectInputStream(new FileInputStream("d://Blip3.out"));  
61.        System.out.println("Revovering  b3");  
62.        Blip3 b3 = (Blip3)in.readObject();  
63.        System.out.println(b3);  
64.    }  
65.      
66.    public void write() throws Exception{//写入对象   
67.        Blip3 b3 = new Blip3("A String", 47);  
68.        System.out.println(b3);  
69.        ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("d://Blip3.out"));  
70.        System.out.println("Saving Object");  
71.        o.writeObject(b3);  
72.        o.close();  
73.    }  
74.      
75.    public static void main(String[] args) throws Exception{  
76.        Blip3 b = new Blip3();  
77.        //  b.write();   
78.        b.read();  
79.    }  
80.}  
package com.bird.thinking;

import java.io.Externalizable;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
/**
* @use 第二种可控制序列化变量个数的方式
* @author Bird
*
*/
public class Blip3 implements Externalizable {
        private int i;
        private String s;//没有实例化
        public Blip3(){
                System.out.println("Blip3 Constructor!!");
        }
        //注意  这里的s没有实例化
       
        public Blip3(String x, int a){
                System.out.println("Blip3(String x, int a)");
                s = x;
                i = a;
                //s  和 i实例化在非默认构造函数中
        }
       
        public String toString(){
                return s + i;
        }
       
        public void writeExternal(ObjectOutput out){//可选择写入变量
                System.out.println("Blip3.writeExternal");
                try {
                        out.writeObject(s);
                        out.writeInt(i);
                } catch (IOException e) {
                        throw new RuntimeException(e);
                }//必须进行这两项，否则就一个变量也不出初始化
        }
       
        public void readExternal(ObjectInput in){//可选择读入数据
                System.out.println("Blip3.readExternal");
                try {
                        s = (String)in.readObject();
                        i = in.readInt();
                } catch (ClassNotFoundException e) {
                       
                } catch (IOException e) {
                throw new RuntimeException(e);
                }
               
        }
       
        public void read() throws FileNotFoundException, IOException, ClassNotFoundException{//读取序列化的类
                ObjectInputStream in = new ObjectInputStream(new FileInputStream("d://Blip3.out"));
                System.out.println("Revovering  b3");
                Blip3 b3 = (Blip3)in.readObject();
                System.out.println(b3);
        }
       
        public void write() throws Exception{//写入对象
                Blip3 b3 = new Blip3("A String", 47);
                System.out.println(b3);
                ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("d://Blip3.out"));
                System.out.println("Saving Object");
                o.writeObject(b3);
                o.close();
        }
       
        public static void main(String[] args) throws Exception{
                Blip3 b = new Blip3();
                //        b.write();
                b.read();
        }
}

输出结果为

[html] view plaincopyprint?
01.Blip3 Constructor!!  
02.Blip3(String x, int a)  
03.A String47  
04.Saving Object  
05.Blip3.writeExternal  
Blip3 Constructor!!
Blip3(String x, int a)
A String47
Saving Object
Blip3.writeExternal


[html] view plaincopyprint?
01.Blip3 Constructor!!  
02.Revovering  b3  
03.Blip3 Constructor!!  
04.Blip3.readExternal  

//哥们，够详细了吧，希望对你有帮助。{:soso_e100:}
05.A String47  

---

作者: 黄坚声    时间: 2012-5-11 16:05
对象的序列化和反序列化

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。

把Java对象转换为字节序列的过程称为对象的序列化。

把字节序列恢复为Java对象的过程称为对象的反序列化。

对象的序列化主要有两种用途：

1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；

2） 在网络上传送对象的字节序列。

JDK类库中的序列化API

java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。、

只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以采用默认的序列化方式 。

对象序列化包括如下步骤：

1） 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；

2） 通过对象输出流的writeObject()方法写对象。

对象反序列化的步骤如下：

1） 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；

2） 通过对象输入流的readObject()方法读取对象。

---

作者: 黄坚声    时间: 2012-5-11 16:08
// 对象的序列化和反序列化对应的例子

import java.io.*;

import java.util.Date;

/**

* 对象的序列化和反序列化测试类.     

* @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>

* @version 1.0

* Creation date: 2007-9-15 - 下午21:45:48

*/

public class ObjectSaver {

       /**

        * @param args

        * @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>

        * Creation date: 2007-9-15 - 下午21:45:37

        */

       public static void main(String[] args) throws Exception {

              ObjectOutputStream out = new ObjectOutputStream

                     (new FileOutputStream("D:""objectFile.obj"));

              //序列化对象

              Customer customer = new Customer("阿蜜果", 24);

              out.writeObject("你好!");

              out.writeObject(new Date());

              out.writeObject(customer);

              out.writeInt(123); //写入基本类型数据

              out.close();

              //反序列化对象

              ObjectInputStream in = new ObjectInputStream

                     (new FileInputStream("D:""objectFile.obj"));

              System.out.println("obj1=" + (String) in.readObject());

              System.out.println("obj2=" + (Date) in.readObject());

              Customer obj3 = (Customer) in.readObject();

              System.out.println("obj3=" + obj3);

              int obj4 = in.readInt();

              System.out.println("obj4=" + obj4);

              in.close();

       }

}

class Customer implements Serializable {

       private String name;

       private int age;

       public Customer(String name, int age) {

              this.name = name;

              this.age = age;

       }

       public String toString() {

              return "name=" + name + ", age=" + age;

       }

}

       输出结果如下：

obj1=你好!

obj2=Sat Sep 15 22:02:21 CST 2007

obj3=name=阿蜜果, age=24

obj4=123

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2