java序列化（二）
上一篇我们简单的了解了java的序列化方法。可以想一下，如果有两个类，如果父类实现了序列化，子类没有实现序列化，子类在进行对象序列化读写时，父类和子类均被实现序列化。如果其中父类没有实现序列化，子类实现了序列化，那么序列化和反序列化会发生什么情况呢？大胆猜测一下，父类没有经过序列化，所以他的属性不会被保留下来，在反序列化时应该没值。下面分两种情况验证一下。
第一种是父类无空参构造函数
package serializable.testone; /** * @Description: 未实现序列化的父类 * @Author: haoqiangwang3 * @CreateDate: 2020/1/3 */ public class Biology { public String type; private int num; /** * 父类构造函数 * @param type * @param num */ public Biology(String type, int num){ this.type = type; this.num = num; } public String getType() { return type; } public void setType(String type) { this.type = type; } public int getNum() { return num; } public void setNum(int num) { this.num = num; } }
子类继承父类，并实现了序列化
package serializable.testone; import java.io.Serializable; /** * @Description: 实现序列化的子类 * @Author: haoqiangwang3 * @CreateDate: 2020/1/3 */ public class PeoPle extends Biology implements Serializable { public String name; protected String gender; private int age; /** * 子类构造函数 * @param type * @param num * @param name * @param gender * @param age */ public PeoPle(String type, int num, String name, String gender, int age){ super(type,num); this.name = name; this.gender = gender; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getGender() { return gender; } public void setGender(String gender) { this.gender = gender; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
最后测试一下结果
package serializable.testone; import java.io.*; /** * @Description: 测试类 * @Author: haoqiangwang3 * @CreateDate: 2020/1/3 */ public class TestOne { public static void main(String[] args) throws IOException, ClassNotFoundException { PeoPle peoPle = new PeoPle("human",10000,"张三","男",25); //序列化，写到文件中 FileOutputStream fos = new FileOutputStream("test.txt"); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(peoPle); oos.flush(); oos.close(); System.out.println("序列化成功..."); //反序列化 FileInputStream fis = new FileInputStream("test.txt"); ObjectInputStream ois = new ObjectInputStream(fis); PeoPle p = (PeoPle)ois.readObject(); System.out.println("p.getType() = " + p.getType()); System.out.println("p.getNum() = " + p.getNum()); System.out.println("p.getName() = " + p.getName()); System.out.println("p.getGender() = " + p.getGender()); System.out.println("p.getAge() = " + p.getAge()); } }
运行结果如下：
序列化成功... Exception in thread "main" java.io.InvalidClassException: serializable.testone.PeoPle; no valid constructor at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:169) at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:874) at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2043) at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1573) at java.io.ObjectInputStream.readObject(ObjectInputStream.java:431) at serializable.testone.TestOne.main(TestOne.java:26)
可以发现，序列化成功了，但是反序列化的时候发生了异常。
第二种，父类含有无参构造函数。
package serializable.testtwo; public class Person { public String name; public String gender; public int age; float height; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getGender() { return gender; } public void setGender(String gender) { this.gender = gender; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public float getHeight() { return height; } public void setHeight(float height) { this.height = height; } }
子类如下
package serializable.testtwo; import java.io.Serializable; public class Male extends Person implements Serializable { private static final long serialVersionUID = 1L; public boolean beard; protected String weight; public boolean haveBeard(int age){ boolean flag = false; if(age >= 18){ flag = true; } return flag; } public boolean isBeard() { return beard; } public void setBeard(boolean beard) { this.beard = beard; } public String getWeight() { return weight; } public void setWeight(String weight) { this.weight = weight; } }
测试类：
package serializable.testtwo; import java.io.*; public class TestTwo { public static void main(String[] args) throws IOException, ClassNotFoundException { /**Male继承父类Person，自身实现序列化接口，其父类Person没有实现序列化接口*/ FileOutputStream fos = new FileOutputStream("male.txt"); ObjectOutputStream oos = new ObjectOutputStream(fos); Male male = new Male(); /** 父类属性赋值 */ male.setName("张三"); male.setGender("男"); male.setAge(25); male.setHeight(175); /**其自身属性赋值*/ male.setBeard(true); male.setWeight("150"); //序列化 oos.writeObject(male); oos.flush(); oos.close(); //反序列化 FileInputStream fis = new FileInputStream("male.txt"); ObjectInputStream ois = new ObjectInputStream(fis); Male ml = (Male) ois.readObject(); //结果打印 System.out.println("ml.getName() = " + ml.getName()); System.out.println("ml.getGender() = " + ml.getGender()); System.out.println("ml.getHeight() = " + ml.getHeight()); System.out.println("ml.getAge() = " + ml.getAge()); System.out.println("ml.isBeard() = " + ml.isBeard()); System.out.println("ml.getWeight() = " + ml.getWeight()); } }
运行结果如下
ml.getName() = null ml.getGender() = null ml.getHeight() = 0.0 ml.getAge() = 0 ml.isBeard() = true ml.getWeight() = 150
可以发现，序列化和反序列都没有报错，但是反序列化之后父类的属性值都没有。这也验证了我们之前的猜想。
总结一下：
1、非序列化的父类，其子类实现序列化时承担保存和恢复父类public、protected、package等子类可访问到子类的字段；
2、非序列化的父类，其子类进行序列化时，父类需要有用public或者protected修饰的空参构造函数；
3、若无空参构造函数的父类，其子类在运行序列化时将正常进行，但反序列化时会发生错误，并抛出异常。但父类有空参构造函数，子类完成序列化，父类属性却没有参与到序列化中。
其中还有其他稍微复杂的应用，在此就不多说了，详细可以看下此文章：https://mp.weixin.qq.com/s/Ta0vhFEZL2wGk2x1ES7HHg
