原型模式的定义

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

Prototype原型模式是一种创建型设计模式，Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。

模型：

通过模型发现，就是通过Clone()方法来实现对对象的拷贝。

实例说明

比如某平台举行抽奖送福利的活动，中奖的通知以邮件形式发送。思考一下，这里需要一个邮件Mail类用来填写姓名，内容等信息。

下面实例说明，先写普通Mail类和调用，然后再写出原型模式的。

1.没有实现Clone()方法的Mail类：


public class Mail  {
   //姓名
    private  String name;
    //地址
    private  String address;
    //内容
    private  String content;
    public    Mail(){
        Log.e("qzs","构造方法");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
}

2.调用


private int MAIL_COUNT=10;
   Mail mail=new Mail();
         for (int i=0;i<MAIL_COUNT;i++){
             mail.setName("姓名"+i);
             mail.setAddress("www.xxx"+i+".com");
             mail.setContent("xxxxx");
             sendMail(mail);
         }
   public void sendMail (Mail mail){
       Log.e("qzs",mail.getName()+"邮件发送成功了");
   }

运行：

考虑一个问题，需要发送邮件的数量很多的话，会很耗时。这时可以用我们今天的讲的原型模式，来“克隆”出属性一致的对象来实现。

下面修改了一个Mail类：


public class Mail  implements  Cloneable{
   //姓名
    private  String name;
    //地址
    private  String address;
    //内容
    private  String content;
    public    Mail(){
        Log.e("qzs","构造方法");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    @Override
    protected Mail clone() throws CloneNotSupportedException {
        Log.e("qzs","clone");
        Mail mail=null;
        try {
            mail= (Mail) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return mail;
    }
}

调用：


try {
            Mail mail=new Mail();
            Mail mail_clone=mail.clone();
            for (int i=0;i<MAIL_COUNT;i++){
                mail_clone.setName("姓名"+i);
                mail_clone.setAddress("www.xxx"+i+".com");
                mail_clone.setContent("xxxxx");
                sendMail(mail_clone);
            }
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
   public void sendMail (Mail mail){
       Log.e("qzs",mail.getName()+"邮件发送成功了");
   }

运行:

原型模式优点

原型模式是在内存中二进制流的拷贝，要比直接new一个对象性能好很多，尤其是构造函数比较复杂，并且在循环体中生产出大量的对象时，用原型模式效率很高。

原型模式-在拷贝时构造函数是不执行的。(上面的例子中已经发现了)

深拷贝与浅拷贝

浅拷贝：在通过Clone() 方法实现拷贝对象时，只是对对象的拷贝，而没有对原生对象的其他因素进行拷贝，所以拷贝出的对象还指向原生的。

深拷贝：这就好理解了，拷贝对象和原生对象是分开的。

下面通过一个例子来说明一下：


public class Text implements  Cloneable{
 private ArrayList<String> list=new ArrayList<>();
    @Override
    protected Text  clone() throws CloneNotSupportedException {
          Text text=null;
          text= (Text) super.clone();
        return text;
    }
    public void  setList(String str){
        this.list.add(str);
    }
      public ArrayList<String> getList(){
          return this.list;
      } 
}

调用：


    Text text=new Text();
            Text text_clone=text.clone();
            text.setList("1");
            text_clone.setList("2");
            Log.e("qzs",text.getList()+"");

我只打印的是原生对象的集合，但是运行的结果确实：

正好印证了我前面说的，这是浅拷贝。

如果想要深拷贝，在clone()方法中改一下就可以了，其实就是对私有的变量list进行了拷贝：


@Override
    protected Text  clone() throws CloneNotSupportedException {
          Text text=null;
          text= (Text) super.clone();
        //更改的
        text.list= (ArrayList<String>) this.list.clone();
        return text;
    }

文章学习参考了《设计模式之禅》《大话设计模式》等等