设计模式读书笔记-----原型模式

      以前听过这样一句话：“程序员的最高境界就是Ctrl+C、Ctrl+V”，我们先不论这句话的对错，就论这个过程，这个过程我们都知道无非就是复制一个对象，然后将其不断地粘贴。这样的过程我们可以将其称之为“克隆”。再如我们应聘的时候打印了那么多的简历。

       克隆我们都清楚，就是用一个物体复制若干个一模一样物体。同样，在面向对象系统中，我们同样可以利用克隆技术来克隆出若干个一模一样的对象。在应用程序中，有些对象比较复杂，其创建过程过于复杂，而且我们又需要频繁的利用该对象，如果这个时候我们按照常规思维new该对象，那么务必会带来非常多的麻烦，这个时候我们就希望可以利用一个已有的对象来不断对他进行复制就好了，这就是编程中的“克隆”。这里原型模式就可以满足我们的“克隆”，在原型模式中我们可以利用过一个原型对象来指明我们所要创建对象的类型，然后通过复制这个对象的方法来获得与该对象一模一样的对象实例。这就是原型模式的设计目的。

一、模式定义

      通过前面的简单介绍我们就可以基本确定原型模式的定义了。所谓原型模式就是用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。

      在原型模式中，所发动创建的对象通过请求原型对象来拷贝原型对象自己来实现创建过程，当然所发动创建的对象需要知道原型对象的类型。这里也就是说所发动创建的对象只需要知道原型对象的类型就可以获得更多的原型实例对象，至于这些原型对象时如何创建的根本不需要关心。

      讲到原型模式了，我们就不得不区分两个概念：深拷贝、浅拷贝。

      浅拷贝：使用一个已知实例对新创建实例的成员变量逐个赋值，这个方式被称为浅拷贝。

     深拷贝：当一个类的拷贝构造方法，不仅要复制对象的所有非引用成员变量值，还要为引用类型的成员变量创建新的实例，并且初始化为形式参数实例值。

      对于深拷贝和浅拷贝的详细情况，请参考这里：渐析java的浅拷贝和深拷贝

二、模式结构

      下图是原型模式的UML结构图：

       原型模式主要包含如下三个角色：

       Prototype：抽象原型类。声明克隆自身的接口。
       ConcretePrototype：具体原型类。实现克隆的具体操作。
       Client：客户类。让一个原型克隆自身，从而获得一个新的对象。

      我们都知道Object是祖宗，所有的Java类都继承至Object，而Object类提供了一个clone()方法，该方法可以将一个java对象复制一份，因此在java中可以直接使用clone()方法来复制一个对象。但是需要实现clone的Java类必须要实现一个接口:Cloneable.该接口表示该类能够复制且具体复制的能力，如果不实现该接口而直接调用clone()方法会抛出CloneNotSupportedException异常。如下：

public class PrototypeDemo implements Cloneable{
　　public Object clone(){
　　　　Object object = null;
　　　　try {
　　　　　　object = super.clone();
　　　　} catch (CloneNotSupportedException exception) {
　　　　　　System.err.println("Not support cloneable");
　　　　}
　　　　return object;
    }
    ……
}

      Java中任何实现了Cloneable接口的类都可以通过调用clone()方法来复制一份自身然后传给调用者。一般而言，clone()方法满足：
      (1) 对任何的对象x，都有x.clone() !=x，即克隆对象与原对象不是同一个对象。
      (2) 对任何的对象x，都有x.clone().getClass()==x.getClass()，即克隆对象与原对象的类型一样。
      (3) 如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。

三、模式实现

      复印简历各位都应该做过吧！这里我们利用原型模式来模拟复印简历。

      简历：Resume.java

public class Resume implements Cloneable {
    private String name;
    private String birthday;
    private String sex;
    private String school;
    private String timeArea;
    private String company;
    
    /**
     * 构造函数：初始化简历赋值姓名
     */
    public Resume(String name){
        this.name = name;
    }
    
    /**
     * @desc 设定个人基本信息
     * @param birthday 生日
     * @param sex 性别
     * @param school 毕业学校
     * @return void
     */
    public void setPersonInfo(String birthday,String sex,String school){
        this.birthday = birthday;
        this.sex = sex;
        this.school = school;
    }
    
    /**
     * @desc 设定工作经历
     * @param timeArea 工作年限
     * @param company 所在公司
     * @return void
     */
    public void setWorkExperience(String timeArea,String company){
        this.timeArea = timeArea;
        this.company = company;
    }
    
    /**
     * 克隆该实例
     */
    public Object clone(){
        Resume resume = null;
        try {
            resume = (Resume) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return resume;
    }
    
    public void display(){
        System.out.println("姓名：" + name);
        System.out.println("生日:" + birthday + ",性别:" + sex + ",毕业学校：" + school);
        System.out.println("工作年限:" + timeArea + ",公司:" + company);
    }

}

      客户端:Client.java

public class Client {
    public static void main(String[] args) {
        //原型A对象
        Resume a = new Resume("小李子");
        a.setPersonInfo("2.16", "男", "XX大学");
        a.setWorkExperience("2012.09.05", "XX科技有限公司");
        
        //克隆B对象
        Resume b = (Resume) a.clone();
        
        //输出A和B对象
        System.out.println("----------------A--------------");
        a.display();
        System.out.println("----------------B--------------");
        b.display();
        
        /*
         * 测试A==B?
         * 对任何的对象x，都有x.clone() !=x，即克隆对象与原对象不是同一个对象
         */
        System.out.print("A==B?");
        System.out.println( a == b);
        
        /*
         * 对任何的对象x，都有x.clone().getClass()==x.getClass()，即克隆对象与原对象的类型一样。
         */
        System.out.print("A.getClass()==B.getClass()?");
        System.out.println(a.getClass() == b.getClass());
    }
}

      运行结果：

四、模式优缺点

优点

      1、如果创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率。

      2、可以使用深克隆保持对象的状态。

      3、原型模式提供了简化的创建结构。

缺点 

      1、在实现深克隆的时候可能需要比较复杂的代码。

      2、需要为每一个类配备一个克隆方法，而且这个克隆方法需要对类的功能进行通盘考虑，这对全新的类来说不是很难，但对已有的类进行改造时，不一定是件容易的事，必须修改其源代码，违背了“开闭原则”。

五、模式使用场景

      1、如果创建新对象成本较大，我们可以利用已有的对象进行复制来获得。

      2、如果系统要保存对象的状态，而对象的状态变化很小，或者对象本身占内存不大的时候，也可以使用原型模式配合备忘录模式来应用。相反，如果对象的状态变化很大，或者对象占用的内存很大，那么采用状态模式会比原型模式更好。
      3、需要避免使用分层次的工厂类来创建分层次的对象，并且类的实例对象只有一个或很少的几个组合状态，通过复制原型对象得到新实例可能比使用构造函数创建一个新实例更加方便。

六、模式总结

      1、原型模式向客户隐藏了创建对象的复杂性。客户只需要知道要创建对象的类型，然后通过请求就可以获得和该对象一模一样的新对象，无须知道具体的创建过程。

      2、克隆分为浅克隆和深克隆两种。

      3、我们虽然可以利用原型模式来获得一个新对象，但有时对象的复制可能会相当的复杂，比如深克隆。