Java 设计模式-原型模式(克隆)

一、什么是原型模式

原型模式(Prototype)，用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。简单说，就是从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建细节。

二、原型的引入克隆

现在我们有一个需求，要求有一个简历类，必须要有姓名，可以设置性别和年龄，可以设置工作经历。最终我们需要写三份简历。

通常，在不用原型模式的情况下，是这样实现的。方式一：
简历类

class Resume
{
   private String name;
   private String gender;
   private String age;
   private String timeArea;
   private String company;
   
  public Resume(String name){
      this.name = name;
  }

  public void setPersonInfo(String gender,String age){
     this.gender = gender;
     this.age = age;
  } 

  public void setWorkExperience(String timeArea, String company){
     this.timeArea = timeArea;
     this.company = company;
  }

  public void display(){
     System.out.print(name +" "+ gender +" "+age);
     System.out.print("工作经历 "+ timeArea +" "+company);
  }

}

客户端调用代码

static void main(String[] args){//此处也可为for循环创建
    Resume a = new Resume("张三");
    a.setPersonInfo("男" , "30");
    a.setWorkExperience("2010-2018" , "xx公司");

    Resume b = new Resume("张三");
    b.setPersonInfo("男" , "30");
    b.setWorkExperience("2010-2018" , "xx公司");

    Resume c = new Resume("张三");
    c.setPersonInfo("男" , "30");
    c.setWorkExperience("2010-2018" , "xx公司");

    a.display();
    b.display();
    c.display();

}

结果显示

张三 男 30
工作经历 2010-2018 xx公司
张三 男 30
工作经历 2010-2018 xx公司
张三 男 30
工作经历 2010-2018 xx公司

这里我们看到3份简历需要三次实例化，这样是不是有点麻烦，如果需要100份，那我们就要实例化100次。一旦写错了一个字，都要改100次。
当然我们想偷懒一下，可以这样写。

    Resume a = new Resume("张三");
    a.setPersonInfo("男" , "30");
    a.setWorkExperience("2010-2018" , "xx公司");
    
    Resume b = a;//传引用而不传值
    Resume c = a;
    
    a.display();
    b.display();
    c.display();
    

以上创建对象是通过new方式创建的，但是在我们熟知的概念中，还有一种创建对象的方式是克隆方法。顾名思义，是通过已有的对象复制一个新的对象一模一样的。即我们上面原型模式的定义，所以clone方法是一种原型模式设计模式。下面我们来看一下，克隆方法的使用示例。

//注意此种方式，叫引用复制，得到的对象与原来对象一样，而非创建一个新对象
Resume r = new Resume("张三");
Resume b = r ;

方式二：让被复制的对象类继承接口Cloneable（System已经提供了），并重写clone()方法。

public class Resume implements Cloneable {
    private String name;
    private String gender;
    private String age;
    private String timeArea;
    private String company;

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

    public void setPersonInfo(String gender, String age) {
        this.gender = gender;
        this.age = age;
    }

    public void setWorkExperience(String timeArea, String company) {
        this.timeArea = timeArea;
        this.company = company;
    }

    public void display() {
        System.out.print(name +" "+ gender +" "+age);
        System.out.print("工作经历 "+ timeArea +" "+company);
    }

//只需要调用此方法就可以实现新简历(对象)的生成，且可以再次改新简历的细节
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return (Resume) super.clone();
    }

}

调用代码

Resume resume = Resume("张三丰");
resume.setPersonInfo("男", "30");
resume.setWorkExperience("2010-1018", "xx公司");
Resume cloneResume = (Resume) resume.clone() ; 
cloneResume.setPersonInfo("女", "21");
Resume cloneResume2 = (Resume) resume.clone() ;
cloneResume2.setWorkExperience("2015-2018", "xx公司");

结果为:

张三丰 男 30
工作经历 2010-1018 xx公司
张三丰 女 21
工作经历 2010-1018 xx公司
张三丰 男 30
工作经历 2015-2018 xx公司

两种方法都可以实现。但是方式一每new一次，就需要执行一次构造函数，如果构造行数的执行时间很长，那么多次的执行初始化操作就太低效率了。一般在初始化的信息不发生变化的情况下，方式二克隆是最好的办法。这既隐藏了对象的创建细节，又对性能是大大的提高。不用重新初始化对象，动态获得对象运行时的状态。

三、浅复制与深复制

上面的例子，对象的属性都是String类型，而String类型是一种拥有值类型特点的特殊引用类型。clone()方法是这样的，如果字段是值类型的，则对该字段执行逐位复制，如果字段是引用类型，则复制引用但不复制引用的对象，因此，原始对象及其复本引用同一对象。以简历的例子讲，假设WorkExperience作为简历类的属性，那么在克隆后，会把引用对象中的数据克隆过来吗？

public class Resume implements Cloneable {
    private String name;
    private String gender;
    private String age;
    private WorkExperience experience;

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

    public void setPersonInfo(String gender, String age) {
        this.gender = gender;
        this.age = age;
    }

    public void setWorkExperience(String timeArea, String company) {
        experience.setWorkDate(timeArea);
        experience.setCompany(company);
    }

    public void display() {
        System.out.print(name +" "+ gender +" "+age);
        System.out.print("工作经历 " + experience.getWorkDate() + " " +experience.getCompany());
    }

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

}

工作经验类

public class WorkExperience {
    private String workDate;
    private String company;

    public String getWorkDate() {
        return workDate;
    }

    public void setWorkDate(String workDate) {
        this.workDate = workDate;
    }

    public String getCompany() {
        return company;
    }

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

调用代码

Resume resume = Resume("张三丰");
resume.setPersonInfo("男", "30");
resume.setWorkExperience("2010-1018", "麦当劳公司");

Resume cloneResume = resume.clone() ;
cloneResume.setPersonInfo("男", "22");
cloneResume.setWorkExperience("2017-1018", "肯德基公司");

Resume cloneResume2 = (Resume)resume.clone();
cloneResume2.setPersonInfo("女", "24");
cloneResume2.setWorkExperience("2015-2018", "德克士公司");

resume.display();
cloneResume.display();
cloneResume2.display();

结果显示：

张三丰 男 30
工作经历 2015-2018 德克士公司
张三丰 男 22
工作经历 2015-2018 德克士公司
张三丰 女 24
工作经历 2015-2018 德克士公司

并没有我们想要的结果，三次显示都是最后一次设置的值。通过查帮助文档，我们知道clone()方法是浅表复制，对于值类型，没有什么问题，但对于引用类型，就只是复制了引用，还是指向了原来的对象，所以就会出现上面的结果，三次结果相同。
浅复制，被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。但我们可能更需要这样的一种需求，把要复制的对象所引用的对象都复制一遍。比如刚才的例子，我们希望是a,b,c三个引用的对象都是不同的，复制时就一变二，二变三，此时，我们就叫这种方式为‘深复制’，深复制把引用对象的变量指向复制过的新对象，而不是原有的被引用的对象。

继续改造上面浅复制为深复制

public class Resume implements Cloneable {
    private String name;
    private String gender;
    private String age;
    private WorkExperience experience;

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

    private Resume(WorkExperience experience) {
        this.experience = (WorkExperience) experience.clone();
    }

    public void setPersonInfo(String gender, String age) {
        this.gender = gender;
        this.age = age;
    }

    public void setWorkExperience(String timeArea, String company) {
        experience.setWorkDate(timeArea);
        experience.setCompany(company);
    }

    public void display() {
        System.out.print(name +" "+ gender +" "+age);
        System.out.print("工作经历 " + experience.getWorkDate() + " " +experience.getCompany());
    }

    @Override
    protected Object clone(){
        Resume r = new Resume(this.experience);
        r.name = this.name;
        r.gender = this.gender;
        r.age = this.age;
        return r;
    }

}

工作经验类改造，继承克隆接口，重写clone方法

public class WorkExperience implements Cloneable {
    private String workDate;
    private String company;

    public String getWorkDate() {
        return workDate;
    }

    public void setWorkDate(String workDate) {
        this.workDate = workDate;
    }

    public String getCompany() {
        return company;
    }

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

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

调用代码

Resume resume = Resume("张三丰");
resume.setPersonInfo("男", "30");
resume.setWorkExperience("2010-1018", "麦当劳公司");

Resume cloneResume = resume.clone() ;
cloneResume.setPersonInfo("男", "22");
cloneResume.setWorkExperience("2017-1018", "肯德基公司");

Resume cloneResume2 = (Resume)resume.clone();
cloneResume2.setPersonInfo("女", "24");
cloneResume2.setWorkExperience("2015-2018", "德克士公司");

resume.display();
cloneResume.display();
cloneResume2.display();

结果显示：

张三丰 男 30
工作经历 2010-1018 麦当劳公司
张三丰 男 22
工作经历 2017-1018 肯德基公司
张三丰 女 24
工作经历 2015-2018 德克士公司

这就达到了我们想要的结果，三份不同的简历。由于在一些特定场合，会经常涉及深复制或浅复制，比如说数据集对象DataSet，它就有clone()方法和copy()方法，clone方法用来复制DataSet的结构，但不复制DataSet的数据，实现了原型模式的浅复制。copy方法不但复制结构，也复制数据，其实就是实现了原型模式的深复制。

四、使用场景：

1、资源优化场景。
2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
3、性能和安全要求的场景。
4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
5、一个对象多个修改者的场景。
6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。

五、注意事项：

与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写clone方法。深复制是，采用对象的序列化Serializable技术进行clone,对象的序列化会将对象以及对象的句柄的内容都序列化，然后输出到对象的流中，可以将流直接保存到内存二级制流中，然后再用对象输入流从内存二进制中读取该流，再转换成相应的对象，这样就完成了非常复杂而且是深层次的复制。