原型模式（六）

原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需要知道任何的创建细节。

原型模式需要一个原型类，在Java中的Object类中有clone()方法，只需要实现Cloneable接口即可完成原型模式。
下面以写简历的例子来说明原型模式：
简历包含姓名，年龄以及工作经验信息

简历对象：

public class Resume implements Cloneable {
    private String name;
    private Integer age;
    private WorkExperience workExperience;

    public Resume(String name) {
        this.name = name;
        this.workExperience = new WorkExperience();
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public WorkExperience getWorkExperience() {
        return workExperience;
    }

    public void setWorkExperience(String timeArea, String company) {
        this.workExperience.setTimeArea(timeArea);
        this.workExperience.setCompany(company);
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Resume{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}' +
                "WorkExperience{" +
                "timeArea='" + workExperience.getTimeArea() + '\'' +
                ", company=" + workExperience.getCompany() +
                '}';
    }
}

工作经验对象：

public class WorkExperience {

    private String timeArea;
    private String company;

    public String getTimeArea() {
        return timeArea;
    }

    public void setTimeArea(String timeArea) {
        this.timeArea = timeArea;
    }

    public String getCompany() {
        return company;
    }

    public void setCompany(String company) {
        this.company = company;
    }
}

原型模式测试类：

public class PrototypeTest {
    public static void main(String[] args) {
        Resume resume1 = new Resume("nss");
        resume1.setAge(22);
        resume1.setWorkExperience("xx1年-xx1年", "xx1公司");
        try {
            // 只需要调用clone()方法就可以实现新简历的生成，并且可以再修改新简历的细节
            Resume resume2 = (Resume) resume1.clone();
            // 对象复制后，引用指向新的对象
            System.out.println(resume1.equals(resume2));
            resume2.setAge(23);
            resume2.setWorkExperience("xx2年-xx2年", "xx2公司");
            System.out.println(resume1.toString());
            System.out.println(resume2.toString());
            // resume2更改age后resume1的age不变
            System.out.println(resume1.getAge().equals(resume2.getAge()));
            // resume2更改WorkExperience后resume1的WorkExperience改变
            System.out.println(resume1.getWorkExperience().equals(resume2.getWorkExperience()));
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

Output：

false
Resume{name='nss', age=22}WorkExperience{timeArea='xx2年-xx2年', company=xx2公司}
Resume{name='nss', age=23}WorkExperience{timeArea='xx2年-xx2年', company=xx2公司}
false
true

 

Object类的clone方法：

Object类的clone()方法用来创建当前对象的浅表副本。该方法创建一个新对象，然后将当前对象的非静态字段复制到该新对象。如果字段是值类型的，则对该字段进行逐位复制。如果该字段是引用类型，则复制引用但不复制引用的对象。因此，原始对象及其副本引用同一对象。

浅复制和深复制：

浅复制：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。
clone()方法是浅复制，对于值类型没问题，对于引用类型，就只是复制了引用，对引用对象还是指向了原来的对象。
有时候我们需要把要复制的对象的所有引用对象都复制一变，这种方式叫做深复制。
深复制：深复制把引用对象的变量指向复制过的新对象，而不是原有的被引用的对象。

把上面的代码改为深复制，只需要让WorkExperience实现Cloneable接口并重写clone方法，再修改一下Resume类的clone方法即可：

WorkExperience改为： 

public class WorkExperience implements Cloneable {

    private String timeArea;
    private String company;

    public String getTimeArea() {
        return timeArea;
    }

    public void setTimeArea(String timeArea) {
        this.timeArea = timeArea;
    }

    public String getCompany() {
        return company;
    }

    public void setCompany(String company) {
        this.company = company;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

Resume类clone方法改为：

    /**
     * 对clone方法来说如果字段是值类型的，则对该字段进行逐位复制，如果字段是引用类型，则复制引用但不复制引用的对象
     * 因此，原本的对象及其副本引用的是同一对象。所以如果想让复制的引用类型字段指向新的对象，需要将引用类型对象再复制一份
     * @return
     * @throws CloneNotSupportedException
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Resume resume = (Resume) super.clone();
        resume.workExperience = (WorkExperience) workExperience.clone();
        return resume;
    }

在复制Resume类时，将WorkExperience类也复制一份即可。

再次运行测试类，结果为：

false
Resume{name='nss', age=22}WorkExperience{timeArea='xx1年-xx1年', company=xx1公司}
Resume{name='nss', age=23}WorkExperience{timeArea='xx2年-xx2年', company=xx2公司}
false
false

总结：

使用原型模式的作用：

使用原型模式可以提高性能，因为创建对象时，每new一次，就需要执行一次构造函数，如果构造函数的执行时间很长，那么多次执行这个初始化操作就很低效。

一般在初始化信息不发生变化的情况下，克隆是最好的办法。这既隐藏了对象创建的细节，又对性能是大大的提高。使用原型模式等于是不用重新初始化对象，而是动态的获取对象运行时的状态。

代码获取地址：https://gitee.com/nisen6477/design-patterns.git