对象的序列化与反序列化

对象的序列化与反序列化
        * a: 基本概念
            * 对象的序列化
                * 对象中的数据，以流的形式，写入到文件中保存过程称为写出对象，对象的序列化
                * ObjectOutputStream将对象写道文件中，实现序列化
            * 对象的反序列化
                * 在文件中，以流的形式，将对象读出来，读取对象，对象的反序列化
                * ObjectInputStream 将文件对象读取出来
                    
ObjectOutputStream流写对象
    * A: ObjectOutputStream流写对象
        * a: 简单介绍
             *  IO流对象,实现对象Person序列化,和反序列化
             *  ObjectOutputStream 写对象,实现序列化
             *  ObjectInputStream 读取对象,实现反序列化

        * b: 案例代码
            public class Person implements Serializable{
                public String name;
                public int age;
                public Person(String name, int age) {
                    super();
                    this.name = name;
                    this.age = age;
                }
                public Person(){}
                
                public String getName() {
                    return name;
                }
                public void setName(String name) {
                    this.name = name;
                }
                public int getAge() {
                    return age;
                }
                public void setAge(int age) {
                    this.age = age;
                }
                @Override
                public String toString() {
                    return "Person [name=" + name + ", age=" + age + "]";
                }                
            }
            
            public class ObjectStreamDemo {
                public static void main(String[] args)throws IOException, ClassNotFoundException {
            //        writeObject();
                    readObject();
                }
                /*
                 * ObjectOutputStream
                 * 构造方法: ObjectOutputStream(OutputSteam out)
                 * 传递任意的字节输出流
                 * void writeObject(Object obj)写出对象的方法
                 */
                public static void writeObject() throws IOException{
                    //创建字节输出流,封装文件
                    FileOutputStream fos = new FileOutputStream("c:\\person.txt");
                    //创建写出对象的序列化流的对象,构造方法传递字节输出流
                    ObjectOutputStream oos = new ObjectOutputStream(fos);
                    Person p = new Person("lisi",25);
                    //调用序列化流的方法writeObject,写出对象
                    oos.writeObject(p);
                    oos.close();
                }
            }
            
ObjectInputStream流读取对象
    * A: ObjectInputStream流读取对象
        * a: 简单介绍
            * ObjectInputStream
            * 构造方法:ObjectInputStream(InputStream in)
            * 传递任意的字节输入流,输入流封装文件,必须是序列化的文件
            * Object readObject()  读取对象
        * b: 案例代码
            /*
             *  IO流对象,实现对象Person序列化,和反序列化
             *  ObjectOutputStream 写对象,实现序列化
             *  ObjectInputStream 读取对象,实现反序列化
             */
            public class ObjectStreamDemo {
                public static void main(String[] args)throws IOException, ClassNotFoundException {
                    readObject();
                }
                /*
                 * ObjectInputStream
                 * 构造方法:ObjectInputStream(InputStream in)
                 * 传递任意的字节输入流,输入流封装文件,必须是序列化的文件
                 * Object readObject()  读取对象
                 */
                public static void readObject() throws IOException, ClassNotFoundException{
                    FileInputStream fis = new FileInputStream("c:\\person.txt");
                    //创建反序列化流,构造方法中,传递字节输入流
                    ObjectInputStream ois = new ObjectInputStream(fis);
                    //调用反序列化流的方法 readObject()读取对象
                    Object obj =ois.readObject();
                    System.out.println(obj);
                    ois.close();
                }                
            }
                        
静态不能序列化
    * A: 静态不能序列化
        * a: 原因
            * 序列化是把对象数据进行持久化存储
            * 静态的东西不属于对象，而属于类
 
transient关键字
    * A: transient关键字
        * a: 作用
            * 被transient修饰的属性不会被序列化
            * transient关键字只能修饰成员变量
            
        
Serializable接口的含义
    * A：Serializable接口的含义
        * a: 作用
            * 给需要序列化的类上加标记。该标记中没有任何抽象方法
            * 只有实现了 Serializable接口的类的对象才能被序列化
                
序列化中的序列号冲突问题
    * A: 序列化中的序列号冲突问题
        * a: 问题产生原因
            * 当一个类实现Serializable接口后，创建对象并将对象写入文件，之后更改了源代码(比如：将成员变量的修饰符有private改成public)，
                再次从文件中读取对象时会报异常
       

序列化中自定义的序列号
    * A: 序列化中自定义的序列号
        * a: 定义方式
            * private static final long serialVersionUID = 1478652478456L;
                * 这样每次编译类时生成的serialVersionUID值都是固定的     
        
        * b: 案例代码
            public class Person implements Serializable{
                public String name;
                public /*transient阻止成员变量序列化*/ int age;
                //类,自定义了序列号,编译器不会计算序列号
                private static final long serialVersionUID = 1478652478456L;

                public Person(String name, int age) {
                    super();
                    this.name = name;
                    this.age = age;
                }
                public Person(){}
                
                public String getName() {
                    return name;
                }
                public void setName(String name) {
                    this.name = name;
                }
                public int getAge() {
                    return age;
                }
                public void setAge(int age) {
                    this.age = age;
                }
                @Override
                public String toString() {
                    return "Person [name=" + name + ", age=" + age + "]";
                }                
            }

备注：由于个人原因，本博客暂停更新。如有问题可联系本人，本人提供技术指导、学习方向、学习路线。本人微信wlp1156107728(添加注明来意)   QQ1156107728(添加注明来意)