java输入输出（9） 对象引用的序列化

1. 在java中，如果一个序列化的类的成员变量类型是其他类的引用，那么这个引用类也必须是可序列化的。
2. 在java中，为了避免对一个对象的重复序列化，，java序列化机制采用了一种特殊的序列化算法，即是：
   1. 所有保存到磁盘中的（即序列化后保存）的对象都有一个序列化编号
   2. 在程序试图序列化一个对象时，系统将先检查该对象是否已经被序列化过，只有未被序列化过的对象，系统才会对该对象进行序列化
   3. 如果检查出来该对象是已经被序列化过的，那么程序就直接输出一个序列化编号，而不是再次序列化该对象
3. 具体的讲解穿插在下面的代码中

   public class Teacher implements java.io.Serializable {
       private String name;
       private Person student;
   //    在这里，Person类必须是可序列化的，否则将导致Teacher类也变成不可序列化
   
       public Teacher(String name, Person student){
           this.name = name;
           this.student = student;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public Person getStudent() {
           return student;
       }
   
       public void setStudent(Person student) {
           this.student = student;
       }
   }
   

   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.io.ObjectOutputStream;
   
   public class WriteTeacher {
       public static void main(String args[]){
           try{
               ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("teacher.txt"));
   
               Person person = new Person("孙悟空",500);
   //
               Teacher teacher1 = new Teacher("唐僧", person);
               Teacher teacher2 = new Teacher("菩提祖师", person);
   
   //           在这里连续用了四次调用writeObject，但是只有第一次是真正有把person这个对象序列化的，
   //            可以在readTeacher中看到证明
               oos.writeObject(teacher1);
               oos.writeObject(teacher2);
               oos.writeObject(person);
               oos.writeObject(teacher2);
   
   
           }catch (IOException e){
               e.printStackTrace();
           }
   
       }
   }
   
   

   import java.io.FileInputStream;
   import java.io.ObjectInputStream;
   
   public class ReadTeacher {
       public static void main(String args[]){
           try{
               ObjectInputStream ois = new ObjectInputStream(new FileInputStream("teacher.txt"));
   
   //            在这里，因为系统只对person对象序列化了一次，所以teacher1，teacher2中的person是一样的
   //            同理，系统也只是对teacher2序列化了一次，所以teacher3==teacher2是为true的
               Teacher teacher1 = (Teacher)ois.readObject();
               Teacher teacher2 = (Teacher)ois.readObject();
               Person p = (Person)ois.readObject();
               Teacher teacher3 = (Teacher)ois.readObject();
   
   
   
               System.out.println("t1的student引用和p是否相同：" + (teacher1.getStudent() == p));
               System.out.println("t2的student引用和p是否相同：" + (teacher2.getStudent() == p));
               System.out.println("t2和t3是否是同一个对象"+(teacher2 == teacher3));
           }catch (Exception e){
               e.printStackTrace();
           }
       }
   }
   //运行程序可以看到：
   //        t1的student引用和p是否相同：true
   //        t2的student引用和p是否相同：true
   //        t2和t3是否是同一个对象true