序列化：java.io.Serializable

java.io.Serializable引发的问题——什么是序列化？在什么情况下将类序列化？

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

序列化:序列化是将对象转换为容易传输的格式的过程。例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象。在另一端，反序列化将从该流重新构造对象。
是对象永久化的一种机制。

　　 确切的说应该是对象的序列化，一般程序在运行时，产生对象，这些对象随着程序的停止运行而消失，但如果我们想把某些对象（因为是对象，所以有各自不同的特性）保存下来，在程序终止运行后，这些对象仍然存在，可以在程序再次运行时读取这些对象的值，或者在其他程序中利用这些保存下来的对象。这种情况下就要用到对象的序列化。

　　 只有序列化的对象才可以存储在存储设备上。为了对象的序列化而需要继承的接口也只是一个象征性的接口而已，也就是说继承这个接口说明这个对象可以被序列化了，没有其他的目的。之所以需要对象序列化，是因为有时候对象需要在网络上传输，传输的时候需要这种序列化处理，从服务器硬盘上把序列化的对象取出，然后通过网络传到客户端，再由客户端把序列化的对象读入内存，执行相应的处理。

　　 对象序列化是java的一个特征，通过该特征可以将对象写作一组字节码，当在其他位置读到这些字节码时，可以依此创建一个新的对象，而且新对象的状态与原对象完全相同。为了实现对象序列化，要求必须能够访问类的私有变量，从而保证对象状态能够正确的得以保存和恢复。相应的，对象序列化API能够在对象重建时，将这些值还原给私有的数据成员。这是对java语言访问权限的挑战。通常用在服务器客户端的对象交换上面，另外就是在本机的存储。

　　 对象序列化的最主要的用处就是在传递,和保存对象(object)的时候,保证对象的完整性和可传递性。譬如通过网络传输,或者把一个对象保存成一个文件的时候,要实现序列化接口 。
*
Quote:

比较java.io.Externalizable和java.io.Serializable
[URL]http://www.zdnet.com.cn/developer/code/story/0,3800066897,39304080,00.htm[/URL]

即使你没有用过对象序列化（serialization），你可能也知道它。但你是否知道 Java 还支持另外一种形式的对象持久化，外部化（externalization）？

下面是序列化和外部化在代码级的关联方式：

public interface Serializable {}

public interface Externalizable extends Serializable {
void readExternal(ObjectInput in);
void writeExternal(ObjectOutput out);
}

序列化和外部化的主要区别

外部化和序列化是实现同一目标的两种不同方法。下面让我们分析一下序列化和外部化之间的主要区别。

通过Serializable接口对对象序列化的支持是内建于核心 API 的，但是java.io.Externalizable的所有实现者必须提供读取和写出的实现。Java 已经具有了对序列化的内建支持，也就是说只要制作自己的类java.io.Serializable，Java 就会试图存储和重组你的对象。如果使用外部化，你就可以选择完全由自己完成读取和写出的工作，Java 对外部化所提供的唯一支持是接口：

voidreadExternal(ObjectInput in)
void writeExternal(ObjectOutput out)

现在如何实现readExternal() 和writeExternal() 就完全看你自己了。

序列化会自动存储必要的信息，用以反序列化被存储的实例，而外部化则只保存被存储的类的标识。当你通过java.io.Serializable接口序列化一个对象时，有关类的信息，比如它的属性和这些属性的类型，都与实例数据一起被存储起来。在选择走Externalizable这条路时，Java 只存储有关每个被存储类型的非常少的信息。

每个接口的优点和缺点

Serializable接口

· 优点：内建支持

· 优点：易于实现

· 缺点：占用空间过大

· 缺点：由于额外的开销导致速度变比较慢

Externalizable接口

· 优点：开销较少（程序员决定存储什么）

· 优点：可能的速度提升

· 缺点：虚拟机不提供任何帮助，也就是说所有的工作都落到了开发人员的肩上。

在两者之间如何选择要根据应用程序的需求来定。Serializable通常是最简单的解决方案，但是它可能会导致出现不可接受的性能问题或空间问题；在出现这些问题的情况下，Externalizable可能是一条可行之路。

要记住一点，如果一个类是可外部化的（Externalizable），那么Externalizable方法将被用于序列化类的实例，即使这个类型提供了Serializable方法：

private void writeObject()
private void readObject()

1、序列化是干什么的？
简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。

2、什么情况下需要序列化
a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
b）当你想用套接字在网络上传送对象的时候；
c）当你想通过RMI传输对象的时候；

3、当对一个对象实现序列化时，究竟发生了什么？
在没有序列化前，每个保存在堆（Heap）中的对象都有相应的状态（state），即实例变量（instance ariable）比如：

java 代码

1. FoomyFoo=newFoo();
2. myFoo.setWidth(37);
3. myFoo.setHeight(70);

当 通过下面的代码序列化之后，MyFoo对象中的width和Height实例变量的值（37，70）都被保存到foo.ser文件中，这样以后又可以把它 从文件中读出来，重新在堆中创建原来的对象。当然保存时候不仅仅是保存对象的实例变量的值，JVM还要保存一些小量信息，比如类的类型等以便恢复原来的对 象。

java 代码

1. FileOutputStreamfs=newFileOutputStream("foo.ser");
2. ObjectOutputStreamos=newObjectOutputStream(fs);
3. os.writeObject(myFoo);

4、实现序列化（保存到一个文件）的步骤
a）Make a FileOutputStream

java 代码

1. FileOutputStreamfs=newFileOutputStream("foo.ser");

b）Make a ObjectOutputStream

java 代码

1. ObjectOutputStreamos=newObjectOutputStream(fs);

c）write the object

java 代码

1. os.writeObject(myObject1);
2. os.writeObject(myObject2);
3. os.writeObject(myObject3);

d) close the ObjectOutputStream

java 代码

1. os.close();

5、举例说明

java 代码

1. importjava.io.*;
   
3. publicclassBoximplementsSerializable
4. {
5. privateintwidth;
6. privateintheight;
8. publicvoidsetWidth(intwidth){
9. this.width=width;
10. }
11. publicvoidsetHeight(intheight){
12. this.height=height;
13. }
15. publicstaticvoidmain(String[]args){
16. BoxmyBox=newBox();
17. myBox.setWidth(50);
18. myBox.setHeight(30);
20. try{
21. FileOutputStreamfs=newFileOutputStream("foo.ser");
22. ObjectOutputStreamos=newObjectOutputStream(fs);
23. os.writeObject(myBox);
24. os.close();
25. }catch(Exceptionex){
26. ex.printStackTrace();
27. }
28. }
30. }
    

6、相关注意事项
a）序列化时，只对对象的状态进行保存，而不管对象的方法；
b）当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口；
c）当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；
d）并非所有的对象都可以序列化，,至于为什么不可以，有很多原因了,比如：
1.安全方面的原因，比如一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件，或者进行rmi传输 等等，在序列化进行传输的过程中，这个对象的private等域是不受保护的。
2. 资源分配方面的原因，比如socket，thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分 配，而且，也是没有必要这样实现。

import java.io.FileInputStream; 04.import java.io.FileNotFoundException; 05.import java.io.FileOutputStream; 06.import java.io.IOException; 07.import java.io.ObjectInputStream; 08.import java.io.ObjectOutputStream; 09.import java.io.Serializable; 10. 11./* 12. * ObjectInputStream(ObjectOutputStream)用于对象的序列化 13. * 直接对一个对象进行读写，该对象须实现Serializable 14. */ 15.public class ObjectInputStreamDemo { 16. public static void writeObject(String fileName, Object o, boolean isAppend) 17. throws FileNotFoundException, IOException { 18. ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream( 19. fileName, true)); 20. out.writeObject(o); 21. out.close(); 22. } 23. 24. public static Object readObject(String fileName) 25. throws FileNotFoundException, IOException, ClassNotFoundException { 26. ObjectInputStream in = new ObjectInputStream(new FileInputStream( 27. fileName)); 28. Object o = in.readObject(); 29. in.close(); 30. return o; 31. } 32. 33. public static void main(String[] args) { 34. try { 35. ObjectInputStreamDemo.writeObject("file/object", new Person(), 36. false); 37. ((Person) ObjectInputStreamDemo.readObject("file/object")) 38. .display(); 39. } catch (IOException e) { 40. e.printStackTrace(); 41. } catch (Exception e) { 42. e.printStackTrace(); 43. } 44. } 45. 46.} 47. 48.class Person implements Serializable { 49. private String name = "刘海房liuhaifang"; 50. private int sex = 0; 51. 52. Person(String name, int sex) { 53. this.name = name; 54. this.sex = sex; 55. } 56. 57. Person() { 58. } 59. 60. void display() { 61. System.out.println("my name is :" + name); 62. String s = (sex == 0) ? "男" : "女"; 63. System.out.println(s); 64. } 65.}

我写的例子：

package com.one; import java.io.*; public class Box implements Serializable { private int width; private int height; public int getWidth() { return width; } public void setWidth(int width) { this.width = width; } public int getHeight() { return height; } public void setHeight(int height) { this.height = height; } public static void main(String[] args){ Box myBox = new Box(); myBox.setWidth(50); myBox.setHeight(30); try{ FileOutputStream fs = new FileOutputStream("d:\\foo.txt"); ObjectOutputStream os = new ObjectOutputStream(fs); os.writeObject(myBox); os.close(); System.out.println("over"); FileInputStream fis=new FileInputStream("d:\\foo.txt"); ObjectInputStream ois=new ObjectInputStream(fis); Object oo=ois.readObject(); Box bo=(Box)oo; System.out.println("out--"+oo.toString()); System.out.println(bo.getHeight()+"--"+bo.getWidth()); }catch(Exception ex){ ex.printStackTrace(); } } }

输出：

over
out--com.one.Box@10b30a7
30--50