（2.1.18）java之序列化

1-序列化的概念

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

2-特点

1. 一个类能被序列化，那么他的子类也能被序列化
2. static和transient修饰的数据不能被序列化，因为static代表类的状态， transient代表对象的临时数据；
3. serialversionUID判断类的兼容性，待序列的对象和目标类的id不同，则抛出异常，该id为static final的显式定义在类中

3-适用条件

序列化会影响系统的性能，尽量少适用
（1）需要通过网络存储实例对象
（2）需要持久存储实例对象
（3）序列化可以实现深复制

4-示例

import java.io.*;
public class Cat implements Serializable {
        private String name;
        public Cat () {
                this.name = "new cat";
        }
        public String getName() {
                return this.name;
        }
        public void setName(String name) {
                this.name = name;
        }
        public static void main(String[] args) {         
                Cat cat = new Cat();
                try {
                        FileOutputStream fos = new FileOutputStream("catDemo.out");
                        ObjectOutputStream oos = new ObjectOutputStream(fos);
                        System.out.println(" 1> " + cat.getName());
                        cat.setName("My Cat");                       
                        oos.writeObject(cat);
                        oos.close();                       
                } catch (Exception ex) {  ex.printStackTrace();   }
                try {
                        FileInputStream fis = new FileInputStream("catDemo.out");
                        ObjectInputStream ois = new ObjectInputStream(fis);
                        cat = (Cat) ois.readObject();
                        System.out.println(" 2> " + cat.getName());
                        ois.close();
                } catch (Exception ex) {
                        ex.printStackTrace();
                }
        }
}//writeObject和readObject本身就是线程安全的，传输过程中是不允许被并发访问的。所以对象能一个一个接连不断的传过来

5-java.io.Externalizable

上面实现Serializable接口的方式会将所有的成员都序列化，但有时候并不需要将所有成员都序列化成字节流。我们可以让自己的类实现Externalizable接口。Externalizable接口扩展了Serializable接口，并且声明了下面两个抽象方法：
void writeExternal(ObjectOutput out) throws IOException;
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
我们需要实现这两个方法，并且还需要为我们的类提供公有默认构造函数。

public class MyClass implements Externalizable
{
    private String name;
    private int value;

    public MyClass()
    {
        name="hello";
        value=5;
    }
    public MyClass(String name,int value)
    {
        this.name=name;
        this.value=value;
    }

    public void writeExternal(ObjectOutput out) throws IOException
    {
        out.writeObject(name);
        out.writeInt(value);
    }

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
    {
        name=(String)in.readObject();
        value=in.readInt();
    }

    public static void main(String[] args) throws ClassNotFoundException,IOException
    {
        MyClass c=new MyClass("freebird",8);
        ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("myclass.out"));
        out.writeObject(c);

        ObjectInputStream in=new ObjectInputStream(new FileInputStream("myclass.out"));
        MyClass c2=(MyClass)in.readObject();
    }
}