Java 之 I/O 系列 02 ——序列化（二）

Java 之 I/O 系列 目录

Java 之 I/O 系列 01 ——基础

Java 之 I/O 系列 02 ——序列化（一） 

Java 之 I/O 系列 02 ——序列化（二）

 继续上篇的第二个问题

如果一个类实现了Serializable接口，但是它的父类没有实现 ，这个类可不可以序列化？

Object是每个类的超类，但是它没有实现 Serializable接口，但是我们照样在序列化对象，所以说明一个类要序列化，它的父类不一定要实现Serializable接口。但是在父类中定义 的状态能被正确 的保存以及读取吗？

还是围绕上面用过的那些类来做一些修改，看下面这个例子。

Book.java这个类和上次的一样，不实现Serializable接口

public class Book {

    private int isbn;
    public Book(int isbn){
        this.isbn = isbn;
    }
    public int getIsbn() {
        return isbn;
    }
    public void setIsbn(int isbn) {
        this.isbn = isbn;
    }
    
    public String toString(){
        return "Book [isbn = "+isbn+"]";
    }
    
}

这里新定义一个类NewBook继承Book类，并且实现 Serializable接口，下面看定义

ublic class NewBook extends Book implements Serializable {

    private String author;

    public NewBook(int isbn, String author) {
        super(isbn);
        this.author = author;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    @Override
    public String toString() {
        return "NewBook [author=" + author + super.toString() + "]";
    }
}

然后，把Student类中Book类型的实例变量修改成NewBook类型，修改后的Student类

public class Student implements Serializable {

    private NewBook book;
    private String name;

    public Student(NewBook book, String name) {
        super();
        this.book = book;
        this.name = name;

    }
    
    public NewBook getBook() {
        return book;
    }


    public void setBook(NewBook book) {
        this.book = book;
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }


    public String toString() {
        return "Student [book=" + book + ", name=" + name + "]";
    }
    

}

Simulator类的内容不变

public class Simulator {
    public static void main(String[] args) {
        new Simulator().go();
    }

    private void go() {
        Student student = new Student(new NewBook(2014,"author11"), "xingle");
        try {
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("test"));
            out.writeObject(student);
            //System.out.println(System.currentTimeMillis());
            System.out.println("object has been written  ");
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        try {
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("test"));
            Student stuRead = (Student) in.readObject();
            System.out.println("object read here");
            System.out.println(stuRead);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

}

运行这个程序 ，看下输出结果：

 

从结果可以看出，对象写成功了，但在读取的过程中出现了问题，具体的异常原因：no validconstructor，即没有有效的构造函数，那么 到底 是哪个 类没有有效的构造函数呢，到底需要一个什么样的构造函数呢？

对于这种情况 ，即父类没有实现Serializable接口时，但其子类实现 了此接口，那么 这个子类是可以序列化的，但是在反序列化的过程 中会调用 父类 的无参构造函数，上面异常抛出的原因就是因为我们在Book类中没有一个无参的构造函数。好，那我们下面就为Book类添加一个默认的构造函数。

public class Book {

    private int isbn;
    //增加默认构造函数
    public Book(){
        isbn = 100;
        System.out.println("Book class no-arg constructor invoked..");
    }
    public Book(int isbn){
        this.isbn = isbn;
    }
    public int getIsbn() {
        return isbn;
    }
    public void setIsbn(int isbn) {
        this.isbn = isbn;
    }
    
    public String toString(){
        return "Book [isbn = "+isbn+"]";
    }
    
}

再来执行一次程序 ，看输出结果如何：

 可以看到在反序列化的过程中调用了Book类的无参构造执行一个初始化的操作。

 总结一下 ：如果父类没有实现Serializable接口，但其子类实现 了此接口，那么 这个子类是可以序列化的，但是在反序列化的过程 中会调用 父类 的无参构造函数，所以在其直接父类（注意是直接父类）中必须有一个无参的构造函数。

对于第2个问题的讨论就到这里，接下来我们提出第3个问题：

如果将一个对象写入某文件（比如是a），那么之后对这个对象进行一些修改，然后把修改的对象再写入文件a，那么文件a中会包含该对象的两个版本吗？

修改Simulator类如下：

public class Simulator {
    public static void main(String[] args) {
        new Simulator().go();
    }

    private void go() {

        try {
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream("test"));
            Student student = new Student(new NewBook(2014, "testAuthor"),"hehe");                
            out.writeObject(student);
            student.setName("haha");
            out.writeObject(student);
            student.setName("xixi");
            out.writeObject(student);
            System.out.println("object has been written  ");
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            ObjectInputStream in = new ObjectInputStream(new FileInputStream(
                    "test"));
            Student student1 = (Student) in.readObject();
            Student student2 = (Student) in.readObject();
            Student student3 = (Student) in.readObject();
            System.out.println("object read here");
            System.out.println("Student 1 name :"+student1.getName());
            System.out.println("Student 2 name :"+student2.getName());
            System.out.println("Student 3 name :"+student3.getName());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

  执行结果：

object has been written
Book class no-arg constructor invoked..
object read here
Student 1 name :hehe
Student 2 name :hehe
Student 3 name :hehe

它输出了三个hehe，这证明 我们对student名字的修改并没有被写入。原因是序列化输出过程跟踪写入流的对象，试图将同一个对象写入流时，不会导致该对象被复制，而只是将一个句柄写入流，该句柄指向流中相同对象的第一个对象出现的位置。

那我们如何来避免这种情况 ，让它输出三个人名呢，方法是在writeObject()之前调用out.reset()方法，这个方法的作用是清除流中保存的写入对象的记录。

public class Simulator {
    public static void main(String[] args) {
        new Simulator().go();
    }

    private void go() {

        try {
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream("test"));
            Student student = new Student(new NewBook(2014, "testAuthor"),"hehe");                
            out.writeObject(student);
            //Reset will disregard the state of any objects already written to the stream. 
            //The state is reset to be the same as a new ObjectOutputStream
            out.reset();
            student.setName("haha");
            out.reset();
            out.writeObject(student);
            student.setName("xixi");
            out.reset();
            out.writeObject(student);
            System.out.println("object has been written  ");
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            ObjectInputStream in = new ObjectInputStream(new FileInputStream(
                    "test"));
            Student student1 = (Student) in.readObject();
            Student student2 = (Student) in.readObject();
            Student student3 = (Student) in.readObject();
            System.out.println("object read here");
            System.out.println("Student 1 name :"+student1.getName());
            System.out.println("Student 2 name :"+student2.getName());
            System.out.println("Student 3 name :"+student3.getName());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

执行结果：

object has been written
Book class no-arg constructor invoked..
Book class no-arg constructor invoked..
Book class no-arg constructor invoked..
object read here
Student 1 name :hehe
Student 2 name :haha
Student 3 name :xixi

这样修改以后就会输出我们期望的结果了。

好，第3个问题的讨论到此为止，如果想深入了解java序列化，可以看下专门讨论这方面的书。