原型模式(Prototype)（对象、克隆广告邮件）

有些对象创建过程较为复杂，而且有些时候需要频繁的创建，原型模式通过给出一个原型对象来指明所要创建的对象的类型，然后复制这个原型对象的方法创建更多同类型的对象。这就是原型模式的动机。

原型模式的主要思想是基于现有对象克隆一个新的对象出来，一般是有对象的内部提供克隆的方法，通过该方法返回一个对象的副本。在以下几个场景中，使用原型模式会更简单效率也更高。

（1）当一个系统应该独立于它的产品创建、构成和表示时，要使用原型模式。

（2）当要实例化的类是在运行时刻指定时，例如：动态装载。

（3）为了避免创建一个与产品类层次平行的类层次时。

（4）当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆他们可能比每次用合适的状态手工实例化该类更方便一些（也就是当我们在处理一些比较简单的对象，并且对象之间的区别很小，可能只是很固定的几个属性不同的时候，使用原型模式更合适）。

原型模式主要用于对象的复制，它的核心是原型类Prototype。Prototype类需要具备以下两个条件：

（1）实现Cloneable接口： JAVA语言中有一个Cloneable接口，他的作用只用一个，就是在运行时通知虚拟机可以安全的在实现了此接口的类上使用clone方法。在java虚拟机中，只有实现了这个接口的类才可以被复制，否则会抛出异常CloneNotSupportedExceotion

（2）重写Object类中的clone方法。clone()作用是返回对象的一个复制，但其作用域是protected类型的，一般的类无法调用，因此，Prototype类需要将clone方法作用域改为public。

原型模式实现广告模板克隆：

广告模板：

 public class Adv {
 private String subject;
 private String contxt;

 public String getSubject() {
     return subject;
 }
 public void setSubject(String subject) {
     this.subject = subject;
 }
 public String getContxt() {
     return contxt;
 }
 public void setContxt(String contxt) {
     this.contxt = contxt;
 }

 }

mail类 实现可对自身进行克隆：

 /*
  * 实现Cloneable 接口 可以对自身进行克隆
  */
 public class Mail implements Cloneable{
 private  String recrviver = "AAA";
 private String subject = "BBB";
 private String appellation = "CCC";
 private String tail = "DDD";
 private String contxt = "EEE";

 public Mail() {
     super();
 }
 public  Mail(Adv adv) {
     contxt = adv.getContxt();
     subject = adv.getSubject();
 }
 @Override
     public Mail clone() {
         Mail mail = null;
         try {

              //为什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？在运行时刻，Object中的clone()识别出你要复制的是哪一个对象
               // 然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中
             mail= (Mail) super.clone();
         } catch (CloneNotSupportedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         return mail;
     }

 @Override
 public String toString() {
     return "Mail [recrviver=" + recrviver + ", subject=" + subject + ", appellation=" + appellation + ", tail=" + tail
             + ", contxt=" + contxt + "]";
 }
 public String getRecrviver() {
     return recrviver;
 }
 public void setRecrviver(String recrviver) {
     this.recrviver = recrviver;
 }
 public String getSubject() {
     return subject;
 }
 public void setSubject(String subject) {
     this.subject = subject;
 }
 public String getAppellation() {
     return appellation;
 }
 public void setAppellation(String appellation) {
     this.appellation = appellation;
 }
 public String getTail() {
     return tail;
 }
 public void setTail(String tail) {
     this.tail = tail;
 }
 public String getContxt() {
     return contxt;
 }
 public void setContxt(String contxt) {
     this.contxt = contxt;
 }

 }

测试类：

 public class Test {

     public static void main(String[] args) {
 //       Mail m1 = new Mail();
 //       Mail m2 =  m1.clone();
 //      System.out.println( m2.toString());

         Mail mail= new Mail(new Adv());//Adv是广告的模板
         for(int i = 0; i<5;i++){
             Mail m =  mail.clone();//克隆原型邮件
             m.setRecrviver(""+i);//向邮件中添加不同的收件信息
             System.out.println(m.toString());

         }

     }

 }

 Mail [recrviver=0, subject=null, appellation=CCC, tail=DDD, contxt=null]
 Mail [recrviver=1, subject=null, appellation=CCC, tail=DDD, contxt=null]
 Mail [recrviver=2, subject=null, appellation=CCC, tail=DDD, contxt=null]
 Mail [recrviver=3, subject=null, appellation=CCC, tail=DDD, contxt=null]
 Mail [recrviver=4, subject=null, appellation=CCC, tail=DDD, contxt=null]

⑴浅复制（浅克隆）

被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象内存储的引用，而不复制它所引用的对象。

⑵深复制（深克隆）

被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

从以下我们可以看出，clone所进行的时浅克隆们m2只复制了m1所存储的引用当我们对m2做出更改时m1也会改变：

     public static void main(String[] args) {

        Mail m1 = new Mail();
        Mail m2 =  m1.clone();
        System.out.println( m2.toString());

        System.out.println(m1.equals(m2));
        System.out.println(m1.getAppellation().equals(m2.getAppellation()));

 //        Mail mail= new Mail(new Adv());//Adv是广告的模板
 //        for(int i = 0; i<5;i++){
 //            Mail m =  mail.clone();//克隆原型邮件
 //            m.setRecrviver(""+i);//向邮件中添加不同的收件信息
 //            System.out.println(m.toString());
 //
 //        }

     }

 }

Mail [recrviver=AAA, subject=BBB, appellation=CCC, tail=DDD, contxt=EEE] false true

实现深克隆时需要编写的代码会比较复杂，当对象的嵌套结构复杂时由于要实现深克隆，每一层的类都必须支持深克隆。实现起来会比较复杂。

（1）使用原型模式复制不会调用类的构造方法，因为对象的复制是通过调用object类的clone方法来完成的，它直接在内存中复制数据，因此不会调用到类的构造方法，

（2）构造方法中的代码不会执行，甚至脸访问权限都对原型模式无效，所以单例模式与原型模式是冲突的。