实战java设计模式（五）原型模式

1 介绍

用于创建重复的对象，同时又能保证性能。说白了，就是解决对象的复制问题，希望通过Object.clone()直接返回一个复制的对象，注意！！是深拷贝。

2 例子（实现Cloneable接口）

用一个学生类来做实验，学生类里面组合了一个课程。

2.1 课程类

//课程类
class Course implements Cloneable {
    private String courseName;
    private int score;

    //有参构造
    Course(String courseName, int score) {
        this.courseName = courseName;
        this.score = score;
    }
    //设置课程名字
    public void setCourseName(String name){
        this.courseName=name;
    }
    //克隆方法重写
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    //toString
    @Override
    public String toString() {
        return "("+this.courseName+":"+this.score+")";
    }
}

2.2 学生类

//学生类
class Student implements Cloneable {
    private String name;
    public Course course;
    //有参数构造
    Student(String stuName, String courseName, int score) {
        this.course = new Course(courseName, score);
        this.name = stuName;
    }
    //实现
    @Override
    protected Object clone() throws CloneNotSupportedException {
        //首先克隆本类基础数据类型
        Student stuTemp = (Student) super.clone();
        //再将对象类型的克隆
        stuTemp.course = (Course) this.course.clone();//留下一个问题，为什么stuTemp.course是可见的
        return stuTemp;
    }
    //变成字符串
    @Override
    public String toString() {
        return "("+this.name+"->"+this.course.toString()+")";
    }
}

2.3 测试主类

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        //测试
        Student stu1 = new Student("小明", "语文", 85);
        Student stu2 = (Student) stu1.clone();

        //如果不加stuTemp.course = (Course) this.course.clone();结果又会如何
        stu2.course.setCourseName("化学");

        System.out.println(stu1.toString());
        System.out.println(stu2.toString());
    }
}

加与不加stuTemp.course = (Course) this.course.clone()结果会不一样，如果不加二者会共享同一个内存区域的course对象。修改stu2的同时也会修改stu1。

3 反序列化方法

3.1 课程类（可序列化即可）

//课程类
class Course implements Serializable {
    private String courseName;
    private int score;

    //有参构造
    Course(String courseName, int score) {
        this.courseName = courseName;
        this.score = score;
    }
    //设置课程名字
    public void setCourseName(String name){
        this.courseName=name;
    }

    //toString
    @Override
    public String toString() {
        return "("+this.courseName+":"+this.score+")";
    }
}

3.2 学生类

//学生类
class Student implements Serializable {
    private String name;
    public Course course;

    //有参数构造
    Student(String stuName, String courseName, int score) {
        this.course = new Course(courseName, score);
        this.name = stuName;
    }

    //实现
    @Override
    public Student clone() {
        Student student = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try{
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(this);
            oos.close();

            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            student = (Student) ois.readObject();
            ois.close();
        }catch(Exception e){
            e.printStackTrace();
        }
        return student;
    }

    //变成字符串
    @Override
    public String toString() {
        return "("+this.name+"->"+this.course.toString()+")";
    }
}

4 总结

原型模式主要是Object.clone()方法来复制对象要写好。分别是实现Cloneable方法和反序列化。