/**

 * 使用该类测试对象流的读写操作

 *

 */

import java.io.Serializable;

import java.util.Arrays;

public class Person implements Serializable{

    /**

     * 当一个类实现了Serialiazable接口后，编译器会提示

     * 我们应当添加一个常量：serialVersionUID

     * 序列化版本号影响着反序列化的结果，当对象输入流在反序列化

     * 一个实例时会检查该实例与其所属的类的版本是否一致，

     * 不一致则反序列化会抛出版本号不一致的异常。若一致则成功进行反序列化

     *

     * 自行维护版本号可以主动确定反序列化结果。但是若不指定序列化版本号，

     * 编译器在编译当前类时会根据当前类的结构生成一个版本号，但是只要当前类发生改变，

     * 则版本号一定会改变。

     *

     *

     *

     * 当一个类希望被对象流进行读写，那么该类必须实现接口：

     * java.io.Serializable

     * 该接口没有任何抽象方法，这种接口称为：签名接口。

     * 虽然在源代码中不需要重写方法，但实际上编译器在编译该类为class文件时

     * 会根据当前类结构添加一个方法，用于将当前类实例转换为一组字节。

     *

     */

    private static final long serialVersionUID = 1L;

    private String name;

    private int age;

    private String gender;

    /**

     * transient关键字

     * 当一个属性被该关键字修饰后，那么该类的某个实例被序列化时，这个值会被忽略。那么在对象反序列化

     */

    private transient String[] otherInfo;

    //给一个变量添加transient修饰时，进行序列化时不被保留，反序列化时也不被转化。

    //序列化了，这个修饰才会有作用。

    public Person(String name, int age, String gender, String[] otherInfo) {

        super();

        this.name = name;

        this.age = age;

        this.gender = gender;

        this.otherInfo = otherInfo;

    }

    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;

    }

    public String getGender() {

        return gender;

    }

    public void setGender(String gender) {

        this.gender = gender;

    }

    public String[] getOtherInfo() {

        return otherInfo;

    }

    public void setOtherInfo(String[] otherInfo) {

        this.otherInfo = otherInfo;

    }

    @Override

    public String toString() {

        // TODO Auto-generated method stub

        return name + ", " + age + ", " + gender + ","+

                Arrays.toString(otherInfo);

    }

}

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectOutputStream;

/**

 * 对象流

 * java.io.ObjectOutputStream

 * java.io.ObjectInputStream

 *

 * 对象流是一对高级流，使用它们可以很方便进行java中任何对象的读写操作

 * @author 小明

 *

 */

public class OOSDemo {

    public static void main(String[] args) throws IOException {

        // TODO Auto-generated method stub

        String name = "苍老师";

        int age = 18;

        String gender = "女";

        String []otherInfo = {"是一名演员", "爱好是写大字",

                "长得显小", "促进交流", "演员"};

        Person person = new Person(name, age, gender, otherInfo);

        //System.out.println(person);

        /**

         * 将person对象写入文件“person.obj"

         */

        FileOutputStream fos = new FileOutputStream("person.obj");

        /**

         * 为了方便写出对象，连接对象输出流

         */

        ObjectOutputStream obj = new ObjectOutputStream(fos);

        /**

         * 对象输出流提供的方法：

         * void writeObject(Object obj)

         * 该方法用于将给定的对象转换为一组字节后写出。

         * 需要注意，写出的对象必须实现接口：Serializable

         * 否则会抛出异常。

         *

         *下面的操作经历了两个过程

         *1：对象输出流将对象按照结构转化为了一组字节

         *这个过程称为：对象序列化

         *2:文件输出流将这组字节写入到文件中（硬盘上）做长久保存的过程称为：数据持久化。

         *

         *

         *

         */

        obj.writeObject(person);

        System.out.println("写出完毕");

        obj.close();

    }

}

import java.io.FileInputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

public class OISDemo {

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        // TODO Auto-generated method stub

        FileInputStream fis = new FileInputStream("person.obj");

        ObjectInputStream ois = new ObjectInputStream(fis);

        /**

         * 对象流读取字节必须是对象输出流将一个对象

         * 转换的一组字节，否则读取过程会抛出类没有找到的

         * 异常：ClassNotFoundException

         *

         * 将一组字节还原为对象的过程称为：对象反序列化。

         */

        Person person = (Person)ois.readObject();

        System.out.println(person);

        ois.close();

    }

}