模式说明

需要获取一个类的多个实例的场景下，若该类的构造器需要做较多的初始化工作，则创建多个实例会耗时耗资源。可以在创建一个实例后，后续实例都直接拷贝该实例可以避免每次获取实例时的初始化开销，对于需要修改的字段针对性修改即可，这就是原型模式。根据对引用类型字段的拷贝程度分为浅拷贝和深拷贝。

浅拷贝

对原型P的实例p1执行实例p1.clone()方法拷贝给p2时，对p1内的引用类型字段(准确地说是可变引用类型)q(类型Q)，只拷贝其引用。Java中重写clone方法时若只调用super.clone()，则该clone方法在使用时即为浅拷贝，即上述p1.q == p2.q。注意clone方法在Cloneable接口中是native方法，返回类型是Object，赋值给p2时要向下转型。

  1. P p1 = new P();
  2. P p2 = (P)p1.clone();

可以这样描述以上两条语句。p1.clone()在堆中生成一个新的实例，p2是这个新实例的引用(地址)，新实例中有p1的基本数据和不变类型(final修饰的引用类型如String)的完整拷贝，但对于可变的引用类型，只拷贝其引用。即如果p1中有一可变引用字段Q，那么p1.q == p2.q，p1和p2中的q指向同一个实例，即原本p1中的q实例。

深拷贝

以浅拷贝中的描述为例，深拷贝对p中的可变引用类型q，也拷贝一个完整的q到新的地址中(与q并列的Q类型新实例)，此时p1.q !=p2.q。深拷贝要求Q自身也要实现Cloneable接口并重写clone方法。即在原型P的重写clone方法内针对q要有类似如下的语句。

本示例定义一个Person类，使其实现Cloneable接口并通过重写clone方法使其支持浅拷贝。在Person类中定义一个不变引用类型Country和一个非不变引用类型WorkExperience，展示浅拷贝Person时，对不变类型Country拷贝出一个新实例，对非不变引用类型WorkExperience拷贝的是它的引用(地址)。作为对比，本示例定义一个PersonDeep类，该类内有一个非不变引用类型WorkExperienceDeep，使WorkExperienceDeep也实现Cloneable接口并重写clone方法，且在PersonDeep类的clone方法中，针对非不变引用l类型WorkExperienceDeep，执行一条对它的clone方法来得到它的一个实例，从而实现对PersonDeep的深拷贝。

结构

原型接口(通常就是Cloneable)
具体原型类
实现Cloneable接口并重写clone方法，分为深拷贝和浅拷贝。

代码演示

  1. package com.yukiyama.pattern.creation;
  3. /**
  4.  * 原型模式
  5.  */
  6. public class ProtoTypeDemo {
  8.     public static void main(String[] args) {
  9.         System.out.println("====如下是深拷贝示例====");
  10.         // 声明一个支持深拷贝的实例p1
  11.         PersonDeep pd1 = new PersonDeep();
  12.         // 通过原型类中的clone()方法拷贝p1
  13.         PersonDeep pd2 = (PersonDeep) pd1.clone();
  14.         // p1和p2是两个不同的实例，输出“false”
  15.         System.out.println(pd1 == pd2);
  16.         // 设置p1
  17.         pd1.setName("张三");
  18.         pd1.setOccupation("程序员");
  19.         pd1.setWorkExperienceDeep("Alibaba");
  20.         // 设置拷贝而来的p2
  21.         pd2.setName("李四");
  22.         pd2.setOccupation("老师");
  23.         pd2.setWorkExperienceDeep("Tsinghua");
  24.         // 以下3行分别输出“张三”， “程序员”， “Alibaba”
  25.         // WorkExperienceDeep没有被pd2修改为"Tsinghua"，说明PersonDeep是深拷贝类型
  26.         System.out.println(pd1.getName());
  27.         System.out.println(pd1.getOccupation());
  28.         System.out.println(pd1.getWorkExperience().getCompany());
  29.         // 以下3行分别输出“李四”， “老师”， “Tsinghua”
  30.         System.out.println(pd2.getName());
  31.         System.out.println(pd2.getOccupation());
  32.         System.out.println(pd2.getWorkExperience().getCompany());
  33.         // 如下输出“false”，说明p1和p2中的引用类型WorkExperience是不同的实例
  34.         System.out.println(pd1.getWorkExperience() == pd2.getWorkExperience());
  36.         System.out.println("====如下是浅拷贝示例====");
  37.         Person p1 = new Person();
  38.         Person p2 = (Person) p1.clone();
  39.         // p1和p2是两个不同的实例，输出“false”
  40.         System.out.println(p1 == p2);
  41.         // 设置p1
  42.         p1.setName("张三");
  43.         p1.setOccupation("程序员");
  44.         p1.setWorkExperience("Alibaba");
  45.         p1.setCountry("CHINA");
  46.         // 设置拷贝而来的p2
  47.         p2.setName("李四");
  48.         p2.setOccupation("老师");
  49.         p2.setWorkExperience("Tsinghua");
  50.         p2.setCountry("SINGAPORE");
  51.         // 以下4行分别输出“张三”， “程序员”， “Tsinghua”，“CHINA”
  52.         // WorkExperience被p2修改为"Tsinghua"，说明Person是浅拷贝类型
  53.         // 另外，p1中的CHINA并没有因为p2设置为了SINGAPORE而受到影响，
  54.         // 说明自定义的不变类Country在浅拷贝中也拷贝到了新实例，而不是只拷贝其引用
  55.         System.out.println(p1.getName());
  56.         System.out.println(p1.getOccupation());
  57.         System.out.println(p1.getWorkExperience().getCompany());
  58.         System.out.println(p1.getCountry());
  59.         // 以下4行分别输出“李四”， “老师”， “Tsinghua”，“SINGAPORE”
  60.         System.out.println(p2.getName());
  61.         System.out.println(p2.getOccupation());
  62.         System.out.println(p2.getWorkExperience().getCompany());
  63.         System.out.println(p2.getCountry());
  64.         // 如下输出“true”，说明p1和p2中的引用类型WorkExperience是相同的实例
  65.         System.out.println(p1.getWorkExperience() == p2.getWorkExperience());
  66.         // 如下输出“false”，说明p1和p2中的引用类型WCountry是不同的实例
  67.         System.out.println(p1.getCountry() == p2.getCountry());
  68.     }
  69. }
  71. /**
  72.  * 深拷贝版
  73.  * 原型类
  74.  * 实现Cloneable接口并重写clone方法
  75.  * 本类中的非不变引用类型字段也通过该字段自身的clone()进行拷贝
  76.  */
  77. class PersonDeep implements Cloneable{
  78.     private String name;
  79.     private String occupation;
  80.     private int age;
  81.     private WorkExperienceDeep workExperience;
  83.     // 在构造器中实例化引用类型WorkExperience
  84.     public PersonDeep() {
  85.         workExperience = new WorkExperienceDeep();
  86.     }
  88.     public int getAge() {
  89.         return age;
  90.     }
  91.     public void setAge(int age) {
  92.         this.age = age;
  93.     }
  94.     public String getName() {
  95.         return name;
  96.     }
  97.     public void setName(String name) {
  98.         this.name = name;
  99.     }
  100.     public String getOccupation() {
  101.         return occupation;
  102.     }
  103.     public void setOccupation(String occupation) {
  104.         this.occupation = occupation;
  105.     }
  106.     public WorkExperienceDeep getWorkExperience() {
  107.         return workExperience;
  108.     }
  109.     public void setWorkExperienceDeep(String company) {
  110.         this.workExperience.setCompany(company);
  111.     }
  112.     // 重写clone()使得原型类Person能够执行clone()从而被拷贝
  113.     @Override
  114.     protected Object clone() {
  115.         PersonDeep person = null;
  116.         try {
  117.             person = (PersonDeep) super.clone();
  118.             person.workExperience = (WorkExperienceDeep) person.getWorkExperience().clone();
  119.         } catch (CloneNotSupportedException e) {
  120.             e.printStackTrace();
  121.         }
  122.         return person;
  123.     }
  124. }
  126. /**
  127.  * 深拷贝版
  128.  * 原型类型中的引用类型字段
  129.  */
  130. class WorkExperienceDeep implements Cloneable{
  131.     private String company;
  133.     public String getCompany() {
  134.         return company;
  135.     }
  136.     public void setCompany(String company) {
  137.         this.company = company;
  138.     }
  139.     @Override
  140.     protected Object clone() {
  141.         WorkExperienceDeep we = null;
  142.         try {
  143.             we = (WorkExperienceDeep) super.clone();
  144.         } catch (CloneNotSupportedException e) {
  145.             e.printStackTrace();
  146.         }
  147.         return we;
  148.     }
  149. }
  151. /**
  152.  * 浅拷贝版
  153.  * 原型类，实现Cloneable接口并重写clone方法
  154.  */
  155. class Person implements Cloneable{
  156.     private String name;
  157.     private String occupation;
  158.     private int age;
  159.     private WorkExperience workExperience;
  160.     private Country country;
  162.     // 在构造器中实例化引用类型WorkExperience
  163.     public Person() {
  164.         workExperience = new WorkExperience();
  165.     }
  167.     public int getAge() {
  168.         return age;
  169.     }
  170.     public void setAge(int age) {
  171.         this.age = age;
  172.     }
  173.     public String getName() {
  174.         return name;
  175.     }
  176.     public void setName(String name) {
  177.         this.name = name;
  178.     }
  179.     public String getOccupation() {
  180.         return occupation;
  181.     }
  182.     public void setOccupation(String occupation) {
  183.         this.occupation = occupation;
  184.     }
  185.     public WorkExperience getWorkExperience() {
  186.         return workExperience;
  187.     }
  188.     public String getCountry() {
  189.         return country.getCountryName();
  190.     }
  191.     public void setCountry(String countryName) {
  192.         this.country = new Country(countryName);
  193.     }
  195.     public void setWorkExperience(String company) {
  196.         this.workExperience.setCompany(company);
  197.     }
  198.     // 重写clone()使得原型类Person能够对外拷贝
  199.     @Override
  200.     protected Object clone() {
  201.         Person person = null;
  202.         try {
  203.             person = (Person) super.clone();
  204.         } catch (CloneNotSupportedException e) {
  205.             e.printStackTrace();
  206.         }
  207.         return person;
  208.     }
  209. }
  211. /**
  212.  * 浅拷贝版
  213.  * 原型类型中的引用类型字段
  214.  */
  215. class WorkExperience{
  216.     private String company;
  218.     public String getCompany() {
  219.         return company;
  220.     }
  221.     public void setCompany(String company) {
  222.         this.company = company;
  223.     }
  224. }
  226. /**
  227.  * 浅拷贝版
  228.  * 自定义不变类，用于演示在浅拷贝中对不变类的拷贝结果
  229.  */
  230. class Country{
  231.     private String countryName;
  233.     public Country(String countryName) {
  234.         this.countryName = countryName;
  235.     }
  236.     public String getCountryName() {
  237.         return countryName;
  238.     }
  239. }