实现序列化与反序列化，一定要绕开这些坑！

* 

序列化和反序列化 People 对象

*/

private static void testSerializablePeople() throws Exception {

// 序列化的步骤

// 用于存储序列化的文件，这里的java_下划线仅仅为了说明是java序列化对象，没有任何其他含义

File file = new File(“/tmp/people_10.java_”);

if (!file.exists()) {

// 1，先得到文件的上级目录，并创建上级目录

file.getParentFile().mkdirs();

try {

// 2，再创建文件

file.createNewFile();

} catch (IOException e) {

e.printStackTrace();

}

}

People p = new People(10L);

// 创建一个输出流

ObjectOutputStream oos = new ObjectOutputStream(

new FileOutputStream(file)

);

// 输出可序列化对象

oos.writeObject§;

// 关闭输出流

oos.close();

// 反序列化的步骤

// 创建一个输入流

ObjectInputStream ois = new ObjectInputStream(

new FileInputStream(file)

);

// 得到反序列化的对象，这里可以强转为People类型

Object newPerson = ois.readObject();

// 关闭输入流

ois.close();

System.out.println(newPerson);

}

public static void main(String[] args) throws Exception {

testSerializablePeople();

}

}

运行之后，看到磁盘文件因为序列化而多了一个文件

图片

控制台中因反序列化输出的对象信息打印如下：

图片

2.子类实现Serializable接口，父类没有实现，子类可以序列化吗？

去掉父类People的implements Serializable，让父类不实现序列化接口，子类Worker实现序列化接口

public class Worker extends People implements Serializable {

private String name;

private Integer age;

public Worker(Long id, String name, Integer age) {

super(id);

this.name = name;

this.age = age;

}

}

public static void main(String[] args) throws Exception {

testSerizableWorker();

}

/**

* 

子类实现序列化, 父类不实现序列化

* */

private static void testSerizableWorker() throws Exception {

File file = new File(“/tmp/worker_10.java_”);

if (!file.exists()) {

// 1，先得到文件的上级目录，并创建上级目录

file.getParentFile().mkdirs();

try {

// 2，再创建文件

file.createNewFile();

} catch (IOException e) {

e.printStackTrace();

}

}

Worker p = new Worker(10L, “lcy”, 18);

// 创建一个输出流

ObjectOutputStream oos = new ObjectOutputStream(

new FileOutputStream(file)

);

// 输出可序列化对象

oos.writeObject§;

// 关闭输出流

oos.close();

ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));

Object newWorker = ois.readObject(); // 父类没有序列化的时候，需要调用父类的无参数构造方法

ois.close();

System.out.println(newWorker);

}

再次测试运行

图片

结果显示没有有效地构造器，原来是因为父类没有序列化的时候，Object newWorker = ois.readObject()需要直接调用父类的无参数构造方法，不经过子类的无参构造方法。

我们在父类People中加上空的构造方法之后再次执行

图片

结果却发现打印的不是Worker，而是父类People，因为子类没有实现toString而调用父类的toString，所以打印了People对象，至于父类成员变量id为什么是null，原因如下：

1、一个子类实现了 Serializable 接口，它的父类都没有实现 Serializable接口，序列化该子类对象。要想反序列化后输出父类定义的某变量的数值，就需要让父类也实现Serializable接口或者父类有默认的无参的构造函数。

2、在父类没有实现Serializable 接口时，虚拟机是不会序列化父对象的，而一个 Java对象的构造必须先有父对象，才有子对象，反序列化也不例外。所以反序列化时，为了构造父对象，只能调用父类的无参构造函数作为默认的父对象。因此当我们取父对象的变量值时，它的值是调用父类无参构造函数后的值，如果在父类无参构造函数中没有对变量赋值，那么父类成员变量值都是默认值，如这里的Long型就是null。

3、根据以上特性，我们可以将不需要被序列化的字段抽取出来放到父类中，子类实现 Serializable接口，父类不实现Serializable接口但提供一个空构造方法，则父类的字段数据将不被序列化。

最后加上子类Worker的toString方法，打印结果如下：

图片

总结：

• 子类实现Serializable接口，父类没有实现，子类可以序列化！！

• 这种情况父类一定要提供空构造方法，不要忘了子类的toString方法！

3.类中存在引用对象，这个类对象在什么情况下可以实现序列化？

来一个组合对象，里面引用People对象，此时People对象没有实现Serializable接口，能否序列化呢？代码给出来，大家可以自行复制测试一下。

public class Combo implements Serializable {

private int id;

private People people;

public Combo(int id, People people) {

this.id = id;

this.people = people;

}

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public People getPeople() {

return people;

}

public void setPeople(People people) {

this.people = people;

}

@Override

public String toString() {

return “Combo{” +

“id=” + id +

“, people=” + people +

‘}’;

}

}

public class People {

private Long id;

public People() {

}

public People(Long id) {

this.id = id;

}

public Long getId() {

return id;

}

public void setId(Long id) {

this.id = id;

}

@Override

public String toString() {

return “People{” +

“id=” + id +

‘}’;

}

}

private static void testSerializableCombo() throws Exception {

File file = new File(“/tmp/combo_10.java_”);

if (!file.exists()) {

// 1，先得到文件的上级目录，并创建上级目录

file.getParentFile().mkdirs();

try {

// 2，再创建文件

file.createNewFile();

} catch (IOException e) {

e.printStackTrace();

}

}

Combo p = new Combo(1, new People(10L));

// 创建一个输出流

ObjectOutputStream oos = new ObjectOutputStream(

new FileOutputStream(file)

);

// 输出可序列化对象

oos.writeObject§;

// 关闭输出流

oos.close();

ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));

Object newCombo = ois.readObject();

ois.close();

System.out.println(newCombo);

}

public static void main(String[] args) throws Exception {

testSerializableCombo();

}

运行结果如下

图片

直接爆出异常，说明People类没有序列化。

当People加上implements Serializable实现序列化接口后，再次执行如下

图片

总结：

• 一个类里面所有的属性必须是可序列化的，这个类才能顺利的序列化。

比如，类中存在引用对象，那么这个引用对象必须是可序列化的，这个类才能序列化。

4.同一个对象多次序列化之间有属性更新，前后的序列化有什么区别？

下面例子中People是可序列化的，每次序列化之前都会把People的id值修改了，用来观察看看，多次序列化期间，如果对象属性更新，是否会影响序列化，反序列化有什么区别。

/**

* 

同一个对象多次序列化的问题, 坑

* */

private static void sameObjectRepeatedSerialization() throws Exception {

File file = new File(“/tmp/peopele_more.java_”);

if (!file.exists()) {

// 1，先得到文件的上级目录，并创建上级目录

file.getParentFile().mkdirs();

try {

// 2，再创建文件

file.createNewFile();

} catch (IOException e) {

最后

面试是跳槽涨薪最直接有效的方式，马上金九银十来了，各位做好面试造飞机，工作拧螺丝的准备了吗？

掌握了这些知识点，面试时在候选人中又可以夺目不少，暴击9999点。机会都是留给有准备的人，只有充足的准备，才可能让自己可以在候选人中脱颖而出。

什么区别。

/**

* 

同一个对象多次序列化的问题, 坑

* */

private static void sameObjectRepeatedSerialization() throws Exception {

File file = new File(“/tmp/peopele_more.java_”);

if (!file.exists()) {

// 1，先得到文件的上级目录，并创建上级目录

file.getParentFile().mkdirs();

try {

// 2，再创建文件

file.createNewFile();

} catch (IOException e) {

最后

面试是跳槽涨薪最直接有效的方式，马上金九银十来了，各位做好面试造飞机，工作拧螺丝的准备了吗？

掌握了这些知识点，面试时在候选人中又可以夺目不少，暴击9999点。机会都是留给有准备的人，只有充足的准备，才可能让自己可以在候选人中脱颖而出。

[外链图片转存中…(img-2mWU9dgO-1721181699656)]

[外链图片转存中…(img-IzsXcNQ9-1721181699657)]