类实现Serializable接口进行序列化和反序列化操作

目的

SerialVersionUID属性

SerialVersionUID属性的申明方式

显示声明的格式:
private static final long serialVersionUID = xxxxL;

隐式声明依据：
通过包名、类名、继承关系、非私有的公共方法和属性，以及参数、返回值等因素计算出来的，保证这个值是唯一的

测试用例

public class Person implements Serializable{

//显式声明SerialVersionUID;
private static final long serialVersionUID = 55799L;

private String name;
private Integer age;

//省略setter和getter方法
}

public class SerializeUtil{

//传输保存的文件位置
private static String file_name = "d://obj.bin";

//序列化
public void writeObj(Serializable s){
try{
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file_name));
oos.writeObject(s);
System.out.println("序列化成功");
oos.close();
}
catch(Exception e){
e.printStackTrace();
}
}

//反序列化
public Object readObj(){

Object obj = null;
try{

ObjectInputStream input = new ObjectInputStream(new FileInputStream(file_name));
obj = input.readObejct();
input.close();
}
catch(Exception e){
e.printStackTrace();
}
return obj;
}
}

public class Test{

public static void main(String[] args){

//创建持久化对象
Person per1 = new Person();
per1.setName("成兮");
per1.setAge(20);

//进行序列化
SerializeUtil util = new SerializeUtil();
util.writeObj(per1);

//反序列化读取数据
Person per2 = util.readObj();

//测试
System.out.println("我的名字->"+per2.getName()+"    我的年龄->"+per2.getAge());
}
}

部分属性序列化问题

1.private void writeObject(ObjectOutputStream out)：控制序列化的过程
out.defaultWriteObject()：告知JVM按照默认的规则写入对象，该语句一般写在第一行
out.writeXxx：写入相关的数据
2.private void readObject(ObjectInputStream in)：控制反序列化的过程
in.defaultReadObject()：告知JVM按照默认的规则读取对象，该语句一般写在第一行
in.readXxx：读取相关的数据

//Salay工资类
public class Salay{

private static final long serialVersionUID = 24567L;

private Double base;
private Double bounse;

//编写构造器
public Salay(Double base,Double bounse){
this.base = base;
this.bounse = bounse;
}

//省略getter和setter方法
...
}

//编写Person类
public class Person{

private String name;
private Salay salay;

//编写构造器
public Person(String name,Salay salay){
this.name = name;
this.salay = salay;
}

//省略getter和setter方法
...

//编写序列化控制方法
private void writeObject(ObjectOutputStream out)throws IOException{
out.defaultWriteObject();
//控制序列化的参数
out.writeDouble(salay.getBase());
}

//编写反序列化控制方法
private void readObject(ObjectInputStream in)throws IOException{
in.defaultReadObject();
//控制反序列化的参数
salary = new Salay(in.readDouble(),0);
}
}

//序列化操作工具类
public class SerilizeUtil{
//和前面的一样
...
}

//序列化操作类
public class test{
public static void main(String[] args){
Salay salay = new Salay(2000,1200);
Person person = new Person("成兮",salay);
SerializeUtil util = new SerializeUtil();
util.writeObj(person);
}
}

//反序列化操作类
public class test2{
public static void main(String[] args){
SerializeUtil util = new SerilizeUtil();
Person person = util.readObj();
System.out.println("person.name->"+person.getName());
System.out.println("person.base->"+person.getSalay().getBase());
System.out.println("person.bounse->"+person.getSalay().getBounse());
}
}

//最终输出结果:
person.name->成兮
person.base->2000
person.bounse->0

注意

代码测试

//序列化类，包含不可变量
public class Person implements Serializable{
private static final long serialVersionUID = 12345L;
private String name;
public Person(){
this.name = "缘分五月";
}
public String getName(){
return this.name;
}
}

//序列化操作工具类
public class SerializeUtil{
...
}

//序列化测试主类
public class test{
public static void main(String[] args){

Person person = new Person();
SerializeUtil util = new SerializeUtil();
util.writeObj(person);
System.out.println("序列化成功");
}
}

//反序列化测试主类
public class test2{
public static void main(String[] args){

SerializeUtil util = new SerializeUtil();
Person person = util.readObj();
System.out.println("反序列化成功，person.name->"+person.getName());
}
}