Java基础22–对象的输出与输入
对象序列化和反序列化
序列：排队、
把对象转为字节序列，序列化的过程
ObjectOutputStream：用于输出对象，把对象转成字节数据输出，对象的输出过程称为序列化。
ObjectOutputStream比OutputStream多了很多方法，其中一个是 writeObject(obj)
只能将支持 java.io.Serializable 接口的对象写入流中。每个 serializable 对象的类都被编码，编码内容包括类名和类签名、对象的字段值和数组值，以及从初始对象中引用的其他所有对象的闭包。
writeObject 方法用于将对象写入流中。所有对象（包括 String 和数组）都可以通过 writeObject 写入。可将多个对象或基元写入流中。必须使用与写入对象时相同的类型和顺序从相应 ObjectInputstream 中读回对象。
ObjectInputstream：用于输入对象，把字节序列转为对象读取，对象的读取过程称为反序列化。
ObjectInputstream比InputStream多了很多方法，其中一个是 Object readObject()
Serializable接口中没抽象方法，得实现该方法才能ObjectOutputStream输出
User类
public class User implements Serializable{
private String name;
private String password;
private int age;
}//对象需要实现序列化
@Test
public void test01()throws IOException{
User u = new User("chailinyan","123456",28);
FileOutputStream fos = new FileOutputStream("obj.dat");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//数据：程序-->oos --> fos -->obj.dat
oos.writeObject(u);
/*对象是没办法直接变为字节的，没有getBytes（）方法
* 如果没有实现Serializable接口的类型，在序列化时，报错误NotSerializableException，不能序列化。
* 如果要解决问题，User类需要实现java.io.Serializable接口
*/
oos.close();
fos.close();
}
读取对象
@Test
public void test02()throws IOException, ClassNotFoundException{
FileInputStream fis = new FileInputStream("obj.dat");
ObjectInputStream ois = new ObjectInputStream(fis);
Object obj = ois.readObject();
//把字节流中的数据，转为一个对象，读取过程中会创建对象，new对象时需要找对象的类型，若user.java文件不存在会报错找不到类
System.out.println(obj);
ois.close();
fis.close();
}
序列化版本ID：serialVersionUID
将对象写到.dat文件中去了，然后User类发生改变，如下：
public class User implements Serializable{
private String name;
private String password;
private int age;
private char gender;
private String address;
}
这时再运行之前读对象得代码
@Test
public void test02()throws IOException, ClassNotFoundException{
FileInputStream fis = new FileInputStream("obj.dat");
ObjectInputStream ois = new ObjectInputStream(fis);
/*
* 当对象已经输出到文件中后，修改了类，再次读取这个文件时，报InvalidClassException。
* 报这个错的原因是：流中关于类的serialVersionUID与本地类的serialVersionUID对不上，就会报InvalidClassException错误，
* 如何解决？
* （1）修改本地的serialVersionUID为流中的serialVersionUID
* （2）或者，在当初实现Serializable接口时，就固定一个serialVersionUID，这样每次编译就不会自动生成一个新的serialVersionUID
*/
Object obj = ois.readObject();
//把字节流中的数据，转为一个对象，读取过程中会创建对象，new对象时需要找对象的类型
System.out.println(obj);
ois.close();
fis.close();
}
报错：无效的类
流里面得序列化版本和本地的类得序列化版本对不上，因为改变类后本地序列化版本更新了
** 如何解决？**
（1）修改本地的serialVersionUID为流中的serialVersionUID
（2）或者，在当初实现Serializable接口时，就固定一个serialVersionUID，这样每次编译就不会自动生成一个新的serialVersionUID
法一：
修改本地的serialVersionUID为流中的serialVersionUID
再次运行能返回值，gender没有值是因为之前没写
法二：
public class User implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
private String password;
private int age;
在当初实现Serializable接口时，就固定一个serialVersionUID（值随便取，一般加L，因为数字比较大，为long，user实现序列化时类名下有黄色警告线就是因为一般建议固定一个serialVersionUID），这样每次编译就不会自动生成一个新的serialVersionUID，一开始就固定一个serialVersionUID，无论怎么修改都能找到user
回顾：讲自定义异常时：
自定义异常时的要求：
（1）继承Throwable或它的子类
一般是Exception和RuntimeException比较多
（2）建议保留两个构造器，一个无参，一个可以message赋值的构造器
（3）建议增加serialVersionUID
public class TestException {
}
class MyException extends Exception{
//继承异常时也会有黄色线提示，建议固定序列化版本ID
//为什么这个也会这样警告：因为Exception继承了Throwable，而Throwable实现了序列化，所以自定义类也要加序列化版本ID，这样省的自定义异常类更改会导致一些问题，比如像一些异常会记录到日志文件里，下次可能要从日志文件中恢复一些异常信息。类更改后可能会导致日志文件更改不回来，所以在定义异常时，也加入序列化版本ID
private static final long serialVersionUID = 1L;
public MyException() {
super();
}
public MyException(String message) {
super(message);
}
}
不序列的字段：transient和static
需求：
不是对象中的所有属性都需要序列化的。
如果某个属性不需要序列化，可以在属性的前面加一个关键字：transient
如果某个属性是static，那么也不会序列化。因为静态的变量不属于某个对象，而是整个类的，所以不需要随着对象的序列化而序列化。
transient
示例：
若是只想把当时的价格和名称序列化，但当时的销量不需要序列化，因为如果反序列化回来以后，销量应该是目前最新的销量，跟文件里的销量没关系，不希望销量序列化
public class Goods implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
private double price;
private transient int sale;//transient表示sale属性不需要序列化
}
@Test
public void test01()throws IOException{
//现在要序列化这个产品的信息，但是希望销量100不序列化
Goods g = new Goods("裙子",88.8,100);
FileOutputStream fos = new FileOutputStream("goods.dat");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(g);
oos.close();
fos.close();
}
读取对象
@Test
public void test02()throws IOException, ClassNotFoundException{
FileInputStream fis = new FileInputStream("goods.dat");
ObjectInputStream ois = new ObjectInputStream(fis);
Object obj = ois.readObject();
System.out.println(obj);
ois.close();
fis.close();
}
读回来了，销量是0，因为销量属性没有序列化，所以之前的销量100是没有写进去的，销量没有序列化读出来就默认值0
static
加一个静态属性品牌
public class Goods implements Serializable{
private static final long serialVersionUID = 1L;
private static String brand = "尚硅谷";
private String name;
private double price;
private transient int sale;//transient表示sale属性不需要序列化
对象写进去再读出来结果（反序列化结果）：
这时序列化时再改品牌这个属性：
Goods.setBrand("atguigu");
@Test
public void test01()throws IOException{
Goods.setBrand("atguigu");
//现在要序列化这个产品的信息，但是希望销量100不序列化
Goods g = new Goods("裙子",88.8,100);
FileOutputStream fos = new FileOutputStream("goods.dat");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(g);
oos.close();
fos.close();
}
属性的值没改变，还是和之前的一样
对象的引用数据类型属性都要实现Serializable
在序列化Husband对象，要求Wife序列化。
这里发现String类型也实现序列化接口了。
结论：
序列化一个对象时，要求它的属性要么是基本数据类型，如果是引用数据类型，这个引用数据类型也必须实现Serializable接口。
序列化一个数组，要求元素类型实现Serializable接口。
示例：
public class Husband implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
private Wife wife;
public Husband(String name, Wife wife) {
super();
this.name = name;
this.wife = wife;
}
public class Wife {
private String name;
private Husband husband;
public Wife(String name, Husband husband) {
super();
this.name = name;
this.husband = husband;
}
@Test
public void test01()throws Exception {
Husband h = new Husband();
Wife wife = new Wife();
h.setName("崔志恒");
wife.setName("石榴");
h.setWife(wife);
wife.setHusband(h);
FileOutputStream fos = new FileOutputStream("marry.dat");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(h);
/*
* java.io.NotSerializableException: com.atguigu.test10.Wife
* 虽然Husband实现了Serializable，但是因为在序列化Husband过程中，包含wife对象，所以要求Wife类也要实现Serializable接口
*/
oos.close();
fos.close();
}
报错：java.io.NotSerializableException: com.atguigu.test10.Wife
**虽然Husband实现了Serializable，但是因为在序列化Husband过程中，包含wife对象，所以要求Wife类也要实现Serializable接口**
test2
@Test
public void test02(){
Husband h = new Husband();
Wife wife = new Wife();
h.setName("崔志恒");
wife.setName("石榴");
h.setWife(wife);
wife.setHusband(h);
System.out.println(h);
}
打印husband对象是报错：StackOverflowError，栈溢出
打印husband对象对象调用了toString方法，包含了wife对象，wife对象会调用wife的toString方法，wife的toString方法里又有huaband对象，形成了一个死循环
所以toString’方法里不能直接写对象，改为husband.getName()和wife.getName()
String也是引用数据类型，它也实现了序列化
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
