Java 之 序列化接口

一、java.io.Serializable 接口

　　类通过实现 java.io.Serializable 接口以启用其序列化功能，未实现此接口的类型将无法使其任何状态序列化或反序列化。

　　可序列化类的所有子类型本身都是可序列化的。

　　序列化接口没有方法或字段，仅用于标识可序列化的语义。

　　如果实现 Serializable 接口，对象如何序列化，各个属性序列化的顺序是什么，都是默认的，程序员本身无法指定，也不用关心。

　　如果属性前面有  static 和 transient 修饰，该属性不参与序列化。

二、java.io.Externalizable 接口

 　　若某个要完全控制某一对象及其超类型的流格式和内容，则它要实现 Externalizable 接口中的 writeExternal 和 readExternal 方法。

　　程序员要在 writerExternal 方法中，自己定制哪些属性要序列化，顺序是什么样的。

　　程序员要在 readExternal 方法中，自己定制哪些属性要反序列化，顺序与 writerExternal 方法中的一致。

　　Demo：JavaBean 类

 1 import java.io.Externalizable;
 2 import java.io.IOException;
 3 import java.io.ObjectInput;
 4 import java.io.ObjectOutput;
 5 
 6 public class Goods implements Externalizable{
 7     private static String brand = "Made In China";
 8     private String name;
 9     private double price;
10     private transient int sale;
11     public Goods(String name, double price, int sale) {
12         super();
13         this.name = name;
14         this.price = price;
15         this.sale = sale;
16     }
17     public Goods() {
18         super();
19     }
20     public static String getBrand() {
21         return brand;
22     }
23     public static void setBrand(String brand) {
24         Goods.brand = brand;
25     }
26     public String getName() {
27         return name;
28     }
29     public void setName(String name) {
30         this.name = name;
31     }
32     public double getPrice() {
33         return price;
34     }
35     public void setPrice(double price) {
36         this.price = price;
37     }
38     public int getSale() {
39         return sale;
40     }
41     public void setSale(int sale) {
42         this.sale = sale;
43     }
44     @Override
45     public String toString() {
46         return "Goods [brand = " + brand +",name=" + name + ", price=" + price + ",sale = " + sale +"]";
47     }
48     @Override
49     public void writeExternal(ObjectOutput out) throws IOException {
50         //程序员自己定制要序列化的内容，顺序等
51         //这两个方法是在对象被序列化和反序列化的过程中，JVM帮我们调用
52         out.writeUTF(brand);//静态的也序列化
53         out.writeUTF(name);
54         out.writeDouble(price);
55         out.writeInt(sale);//有transient也序列化
56     }
57     @Override
58     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
59         //程序员自己定制要反序列化的内容，顺序等，建议与序列化的顺序一致
60         brand = in.readUTF();
61         name = in.readUTF();
62         price = in.readDouble();
63         sale = in.readInt();
64     }
65     
66 }

 

　　序列化与反序列

 1 import java.io.FileInputStream;
 2 import java.io.FileOutputStream;
 3 import java.io.IOException;
 4 import java.io.ObjectInputStream;
 5 import java.io.ObjectOutputStream;
 6 import org.junit.Test;
 7 
 8 public class TestObject {
 9     @Test
10     public void test01() throws IOException{
11         Goods goods = new Goods("《Java从入门到放弃》", 20.45, 100);
12         Goods.setBrand("China Beijing");
13         
14         FileOutputStream fos = new FileOutputStream("goods.dat");
15         ObjectOutputStream oos = new ObjectOutputStream(fos);
16         
17         oos.writeObject(goods);
18         
19         oos.close();
20         fos.close();
21     }
22     
23     @Test
24     public void test02()throws IOException, ClassNotFoundException{
25         FileInputStream fis = new FileInputStream("goods.dat");
26         ObjectInputStream ois = new ObjectInputStream(fis);
27         
28         Object obj = ois.readObject();
29         System.out.println(obj);
30         
31         ois.close();
32         fis.close();
33     }
34 }

 

来源：https://www.cnblogs.com/niujifei/p/12244812.html