源代码:
package com.serialize;
/**
* Created by IntelliJ IDEA.
* User: Zhong Gang
* Date: 9/26/11
* Time: 11:42 AM
*/
public enum Level {
INFO,
DEBUG,
ERROR
}
package com.serialize;
import java.io.Serializable;
/**
* Created by IntelliJ IDEA.
* User: Zhong Gang
* Date: 9/26/11
* Time: 11:42 AM
*/
public class BasicInfo implements Serializable{
private String city;
private String country;
public BasicInfo(String city, String country) {
this.city = city;
this.country = country;
}
public String getCity() {
return city;
}
public String getCountry() {
return country;
}
}
package com.serialize;
import java.io.Serializable;
/**
* Created by IntelliJ IDEA.
* User: Zhong Gang
* Date: 9/26/11
* Time: 11:38 AM
*/
public class Information implements Serializable{
private int number;
private Integer count;
private String name;
private Level level;
private int[] numbers;
private transient BasicInfo basicInfo;
public Information(int number, Integer count, String name, Level level,int[] numbers, BasicInfo basicInfo) {
this.number = number;
this.count = count;
this.name = name;
this.level = level;
this.numbers = numbers;
this.basicInfo = basicInfo;
}
public int getNumber() {
return number;
}
public Integer getCount() {
return count;
}
public String getName() {
return name;
}
public Level getLevel() {
return level;
}
public BasicInfo getBasicInfo() {
return basicInfo;
}
public int[] getNumbers() {
return numbers;
}
}
package com.serialize;
/**
* Created by IntelliJ IDEA.
* User: Zhong Gang
* Date: 9/26/11
* Time: 1:43 PM
*/
public class ExtendInformation extends Information {
private String description;
public ExtendInformation(int number, Integer count, String name, Level level,int[] numbers, BasicInfo basicInfo, String description) {
super(number, count, name, level,numbers, basicInfo);
this.description = description;
}
public String getDescription() {
return description;
}
}
package com.serialize;
import junit.framework.TestCase;
import java.io.*;
/**
* Created by IntelliJ IDEA.
* User: Zhong Gang
* Date: 9/26/11
* Time: 11:43 AM
*/
public class SerializeTest extends TestCase {
public void testSerializable() throws Exception {
File file = new File("D:\\information.txt");
if (!file.exists()) {
file.createNewFile();
}
BasicInfo basicInfo = new BasicInfo("Chengdu", "China");
Information information = new Information(100, Integer.valueOf("100"), "ZhongGang", Level.ERROR, new int[]{1, 2, 3, 4, 5,}, basicInfo);
ExtendInformation extendInformation = new ExtendInformation(100, Integer.valueOf("100"), "ZhongGang", Level.ERROR, new int[]{1, 2, 3, 4, 5,}, basicInfo, "Ma Ma Mi Ya");
OutputStream outputStream = new FileOutputStream(file);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
objectOutputStream.writeObject(information);
objectOutputStream.writeObject(extendInformation);
InputStream inputStream = new FileInputStream(file);
ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
Information info = (Information) objectInputStream.readObject();
assertEquals(100, info.getNumber());
assertEquals(Integer.valueOf("100"), info.getCount());
assertEquals("ZhongGang", info.getName());
assertEquals(Level.ERROR, info.getLevel());
assertEquals(5, info.getNumbers().length);
BasicInfo basic = info.getBasicInfo();
assertNull(basic);
// assertEquals("Chengdu", basic.getCity());
// assertEquals("China", basic.getCountry());
}
}
结论:
1。序列化适用的情况为当出现系统崩溃或程序运行停止等特殊情况时,为了保存类的实例到磁盘,待下次系统重启或程序再次运行时,重新构造类的实例,或都还原类的实例状态,也适用于在网络中传输类的实例,即在网络中的不同机器上还原类的实例状态。
2。为了实现序列化,需要实现Serializable接口,该接口为一标记接口,没有任何方法,实现该接口的类,表明该项类可以进行序列化与反序列化,通俗地说即是,可以将类的实例即对象转化为流或字节,或者将相应的流或字节转化为相应的对象,前者叫做序列化,而后者叫做反序列化。
3。父类实例了Serializable接口,那么它的子类不需要再次实现Serializable接口,就可以实现序列化。
4。如果某个类的某个属性为非基本类型,基本类型的封装对象,枚举或可序列化数组等对象时,如果该对象没有实现Serializable接口,即没有实例化,那么会导致NoSerialzableException,为了避免此种情况的发生,可以为该对象实现Serializable接口,或者加上transient修饰符,表明在进行序列化时,此属性不会进行序列化。
5。通过序列化保存的类的实例状态为二进制数据,其中不仅包含实例的状态值,还包含序列化号,以及类的名称等必要信息,其中的一些附加信息是为反序列化提供足够的信息。
6。通过序列化实现的功能也可以通过其它一些方式来实现,如通过xml文件等,在xml文件中以特定格式来表述类的实例状态值,这样通过分析xml文件来还原当时的类的实例状态,并且这样的实现,当在网络中进行传输时,还可以对文件进行加密处理,使用起来更加安全。
7。序列化后的信息不包含类的方法