Java--IO--ObjectInputStream和ObjectOutputStream对象处理流

1. 对象处理流：ObjectInputStream和ObjectOutputStream
   1. 
   2. 
   3. 

       

   4. 

   5. 

2.  OjectInputStream和ObjectOuputStream使用案例
   1. 

   2.  序列化：

      1. package com.model.io.outputstream.objectoutputstream;
         
         
         import com.model.io.outputstream.Dog;
         
         import java.io.*;
         
         /**
          * @Description:测试类
          * @Author: 张紫韩
          * @Crete 2021/6/19 8:54
          */
         public class ObjectOutputStreamDemo01 {
             public static void main(String[] args) throws IOException {
                 /**
                  * 新的需求：保存数据是既要保存数据的值还要保存数据的类型
                  * 那么这个保存的过程就是序列化
                  * 还可以对保存的数据恢复数据这个过程叫做：反序列化
                  * 保存的对象想要实现序列化必须实现Serializable接口
                  *
                  * */
                 //声明保存序列化对象的文件路径
                 String filePath = "D:\\qq\\IDEA\\IdeaProjects\\java_mianshi_test\\mianshi_io\\src\\main\\resources\\File\\Serializable.txt";
                 ObjectOutputStream objectOutputStream = null;
                 try {
                     objectOutputStream = new ObjectOutputStream(new FileOutputStream(filePath));
                     objectOutputStream.writeChar('a');
                     objectOutputStream.writeInt(100);
                     objectOutputStream.writeUTF("hello,word");
                     objectOutputStream.writeObject(new Dog("zzh", 18));
                     objectOutputStream.writeBoolean(true);
                     objectOutputStream.writeDouble(100.0);
                 } catch (IOException e) {
                     e.printStackTrace();
                 } finally {
                     try {
                         objectOutputStream.close();
                     } catch (IOException e) {
                         e.printStackTrace();
                     }
                     System.out.println("序列化完成");
                 }
         
         
             }
         }

   3. 

   4. 反序列化：

      1. package com.model.io.inputstream.objectinputstream;
         
         import com.model.io.outputstream.Dog;
         
         import java.io.FileInputStream;
         import java.io.IOException;
         import java.io.ObjectInputStream;
         
         /**
          * @Description:测试类
          * @Author: 张紫韩
          * @Crete 2021/6/18 21:53
          */
         public class ObjectInputStreamDemo01 {
             public static void main(String[] args) throws IOException, ClassNotFoundException {
         
             String filePath="D:\\qq\\IDEA\\IdeaProjects\\java_mianshi_test\\mianshi_io\\src\\main\\resources\\File\\Serializable.txt";
                 ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filePath));
               //反序列化的循序要和序列化的顺序一致
                 System.out.println(objectInputStream.readChar());
                 System.out.println(objectInputStream.readInt());
                 System.out.println(objectInputStream.readUTF());
                 //反序列化的类，我们需要拿到这个类才能实现反序列化
                 Object dog = objectInputStream.readObject();
                 System.out.println(dog.getClass());
                 System.out.println(dog.toString());
         
         //        Dog dog1=(Dog)dog;
                 //当我们们需要调用类中某个属性时，是需要向下转型为Dog类型，但是由于Dog类在另一个类中且不是public我们在另一个类中无法引用
                 //所以会引用失败，无法导入Dog类，且无法使用类中的某个属性
                 //出错原因：Dog类在另一个类文件中，且一个类文件只能有一个public类，Dog类不是public所以在其他的包的类中无法引入Dog类
                 //解决办法：将Dog类放在一个共有的包，且换成一个共有的类，在那个保重都能引入
         
                 //我们将Dog类加入到了outputstream包下，且类型为public，再将两个类中的Dog重新导入一下，
                 Dog dog1=(Dog) dog;
                 System.out.println(dog1.getAge());
                 System.out.println(dog1.getName());
         
                 System.out.println(objectInputStream.readBoolean());
                 System.out.println(objectInputStream.readDouble());
         
                 objectInputStream.close();
                 System.out.println("反序列化完成");
             }
         
         }

3. ObjectInputStream和ObjectOutputStream:对象处理流细节

   1. 序列化的顺序要一致，序列化时写入文件的顺序要和我们反序列化时读的顺序一致，否则会出错
   2. 序列化和反序列化的对象都要实现 Serializable接口，否则无法实现序列化
   3. 序列化的类中建议添加：序列化版本号 

      /**
       * 序列化的对象添加序列化版本号：
       * 增加序列化的兼容性，如果你添加一个属性，他会认为这是这个类的一个升级版，而不是另一个个新的类
       * */
      //序列化版本号，增加兼容性
      private static final long serialVersionUID=1L;

   4. 序列化对象是默认是将所有的属性都进行序列化，但是类中的用static和transent修饰的属性不能进行序列化，序列化时会 自动忽略到这个属性
   5. 序列化对象时，要求类中的属性的类也要进行序列化，否则会报错

      1. 

   6. 序列化具有可继承性，也就是如果某个类已经实现了序列化，则它的子类也已经默认实现了序列化