序列化流：
序列化：将一个对象转换成网络中传输的流
对象输出流：ObjectOutputStream
反序列化：将网络中传输的流还原成一个对象
对象输入流：ObjectInputStream
一个类对象将来要想被序列化，必须要实现Serializable接口，这个接口中没有任何的方法和常量，称为标记接口。
InvalidClassException异常
我们在写完对象后，又修改了类中的内容，又重新写入，再读取的还原对象的时候，报错了InvalidClassException异常 这是因为修改后的UID发生了改变，序列化的对象UID:stream classdesc serialVersionUID = -7948663535168613063, 本地修改后的UID： local class serialVersionUID = 4202380653329948443， 因为没有固定UID,所以每次修改完，UID都会变 解决方案：在Students类里将serialVersionUID写固定，将来谁都不能改，就不会出现修改后错误，不用手写，自动生成即可。
第一步：直接点击异常类
第二步：复制UID
第三步：将复制的UID写入Students类中
第四步：需要重新运行一次程序，只调用write方法，等于将固定UID写入文本中
第五步：修改变量，或者增加其他变量
第六步：修改变量后，只调用read方法，程序也不会报错
总结：序列化对象，要一边修改，一边写入一边读，就不会出现UID不一样的错误
序列化和反序列化使用参考源码：
Students类：
import java.io.Serial;
import java.io.Serializable;
//TODO: 实现序列化需要实现一个Serializable 标记接口（所谓标记接口就是没有任何成员方法和变量，就只是作标记）
//TODO: transient修饰成员变量可以防止被序列化
// 我们在写完对象后，又修改了类中的内容，再读取的还原对象的时候，报错了InvalidClassException
// stream classdesc serialVersionUID = 2442942279365203766,每次写完UID都会变
// local class serialVersionUID = 2935475373948736279
//
// TODO: 解决方案：将serialVersionUID写固定，将来谁都不能改，自动生成即可。
//
//TODO: 若成员不想被序列化存储，使用java提供一个关键字进行修饰 transient
public class Students implements Serializable {
@Serial
private static final long serialVersionUID = -4333316296251054416L;
private String name;
private int age;
private String address;
private int caiFu;
public Students() {
}
public Students(String name, int age, String address,int caiFu) {
this.name = name;
this.age = age;
this.address = address;
}
public String getName() {
return name;
}
public int getCaiFu() {
return caiFu;
}
public void setCaiFu(int caiFu) {
this.caiFu = caiFu;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Students{" +
"name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
", caiFu=" + caiFu +
'}';
}
}
测试类：
import java.io.*;
//TODO:关于序列化流，正常写入文本的对象是什么内容，读出来的也就是什么内容，如果临时修改成员方法，并未及时写入原来的文本中
//TODO:这时候再次读就会报错，原因是每次修改后的序列化UID都会发生改变，所以要想正常读出来，则必须固定UID,但是读出来的新的参数的值是默认值，
//TODO:因为没有立即将新内容写入进去。另外被transient修饰的成员变量不会被序列化，就是普通变量，不会对序列化产生影响
//TODO:总结：序列化对象，要一边修改，一边写入一边读，就不会出现UID不一样的错误
public class XuLeiHuaTest {
public static void main(String[] args) {
// write();
read();
}
public static void write(){
//序列化流（输出流）
ObjectOutputStream ous=null;
try {
ous = new ObjectOutputStream(new FileOutputStream("src/main/java/day15_8_13/序列化流.txt"));
Students s1 = new Students("小伟",18,"山东菏泽",12000);
ous.writeObject(s1);//将对象序列化
ous.flush();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
//用完就释放资源
ous.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void read(){
//反序列化流（输入流）
ObjectInputStream ois=null;
try {
ois = new ObjectInputStream(new FileInputStream("src/main/java/day15_8_13/序列化流.txt"));
try {
Object o = ois.readObject();
//向下转型
Students s1 = (Students) o;
System.out.println(o);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
} catch (IOException e) {
e.printStackTrace();
}finally {
//用完释放资源
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
