什么是java序列化，如何实现java序列化？或者请解释Serializable接口的作用。

Java 串行化技术可以使你将一个对象的状态写入一个Byte 流里，并且可以从其它地方把该Byte 流里的数据读出来，重新构造一个相同的对象。这种机制允许你将对象通过网络进行传播，并可以随时把对象持久化到数据库、文件等系统里。Java的串行化机制是RMI、EJB等技术的技术基础。用途：利用对象的串行化实现保存应用程序的当前工作状态，下次再启动的时候将自动地恢复到上次执行的状态。
序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable接口，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

Java中，一切都是对象，在分布式环境中经常需要将Object从这一端网络或设备传递到另一端。
这就需要有一种可以在两端传输数据的协议。Java序列化机制就是为了解决这个问题而产生。

一个对象能够序列化的前提是实现Serializable接口，Serializable接口没有方法，更像是个标记。
有了这个标记的Class就能被序列化机制处理。

Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization是一种将这些字节重建成一个对象的过程。Java序列化API提供一种处理对象序列化的标准机制。在这里你能学到如何序列化一个对象，什么时候需要序列化以及Java序列化的算法，我们用一个实例来示范序列化以后的字节是如何描述一个对象的信息的。

写了个简单代码演示了一下序列化的用途；
参考一下；

1. package test.bean;
   
2. 
   
3. import java.io.Serializable;
   
4. 
   
5. public class SerializableBean implements Serializable{
   
6.         private static final long serialVersionUID = 1L;
   
7.         private String test;
   
8. 
   
9.         public String getTest() {
   
10.                 return test;
    
11.         }
    
12. 
    
13.         public void setTest(String test) {
    
14.                 this.test = test;
    
15.         }
    
16.        
    
17. }

复制代码

注意必须实行序列化接口；

测试类；

1. package test.bean;
   
2. 
   
3. import java.io.FileInputStream;
   
4. import java.io.FileNotFoundException;
   
5. import java.io.FileOutputStream;
   
6. import java.io.IOException;
   
7. import java.io.ObjectInputStream;
   
8. import java.io.ObjectOutputStream;
   
9. 
   
10. public class FoutSerialiable {
    
11.         public static final String path = "c:\\1.txt";
    
12. 
    
13.         public static void main(String[] args) throws IOException {
    
14.                 /** 序列化到本地代码 */
    
15.                 SerializableBean bean = new SerializableBean();
    
16.                 bean.setTest("PANZERLEADER");
    
17.                 writeObject(bean);
    
18.                 /**
    
19.                  ** 读序列化1.txt代码 SerializableBean bean = readObject();
    
20.                  * System.out.println(bean.getTest());
    
21.                  */
    
22.         }
    
23. 
    
24.         public static SerializableBean readObject() {
    
25.                 ObjectInputStream in = null;
    
26.                 try {
    
27.                         in = new ObjectInputStream(new FileInputStream(path));
    
28.                         return (SerializableBean) in.readObject();
    
29. 
    
30.                 } catch (IOException e) {
    
31.                         e.printStackTrace();
    
32.                 } catch (ClassNotFoundException e) {
    
33.                         // TODO Auto-generated catch block
    
34.                 } finally {
    
35.                         if (in != null) {
    
36.                                 try {
    
37.                                         in.close();
    
38.                                 } catch (IOException e) {
    
39.                                         e.printStackTrace();
    
40.                                 }
    
41.                         }
    
42.                 }
    
43. 
    
44.                 return null;
    
45.         }
    
46. 
    
47.         public static void writeObject(SerializableBean bean) {
    
48.                 ObjectOutputStream out = null;
    
49.                 try {
    
50.                         out = new ObjectOutputStream(new FileOutputStream(path));
    
51.                         out.writeObject(bean);
    
52.                 } catch (FileNotFoundException e) {
    
53.                         // TODO Auto-generated catch block
    
54.                         e.printStackTrace();
    
55.                 } catch (IOException e) {
    
56.                         // TODO Auto-generated catch block
    
57.                         e.printStackTrace();
    
58.                 } finally {
    
59.                         if (out != null)
    
60.                                 try {
    
61.                                         out.close();
    
62.                                 } catch (IOException e) {
    
63.                                         e.printStackTrace();
    
64.                                 }
    
65.                 }
    
66.         }
    
67. 
    
68. }

复制代码

先运行后查看c盘目录1.txt,你会发现
 sr 32test.bean.SerializableBean      

L testt Ljava/lang/String;xpt PANZERLEADER

然后读取，你会发现对象其实已经被你写到了文件中···感谢，看到希望有用，谢谢

楼主穿条内裤就出来了..{:soso_e113:}

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

   序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。