原型模式是什么？

利用一个对象做原型，拷贝生成多个相似的对象叫做原型模式。
是创建复杂对象的一种快速高效的方式。

适用场景

复杂对象，new对象耗时，使用原型模式进行拷贝，提高速度

代码实现

最简单的原型模式

JDK默认提供了原型模式，java.lang.Cloneable接口就是一个原型模式
实现java.lang.Cloneable 方法，重写clone()方法即可实现原型模式，注意两点：

  1. clone()方法是java.lang.Object类提供的，每个对象都默认继承了这个方法，且这个方法是native实现

image.png

  1. 如果不实现java.lang.Cloneable 接口，会报错java.lang.CloneNotSupportedException异常

来一个最简单的原型模式代码实现：

  1. /**
  2.  * 原型模式
  3.  * 原型类 实现JDK的Cloneable接口即可
  4.  */
  5. class Prototype implements Cloneable {
  7.     //具有代表性类型的属性
  8.     private Integer i;//基本类型
  9.     private String s;//字符串类型
  11.     @Override
  12.     protected Object clone() throws CloneNotSupportedException {
  13.         return super.clone();
  14.     }
  16. }
  18. //测试类
  19. public class PrototypeTest {
  20.     public static void main(String[] args) throws InterruptedException, CloneNotSupportedException {
  21.         Prototype p1 = new Prototype();
  22.         Object p2 = p1.clone();
  23.         System.out.println("p1==p2:" + (p1 == p2));
  24.         //输出：p1==p2:false
  25.     }
  26. }

实现Cloneable接口并重写clone()，JDK默认就帮我们实现了原型模式，这就是我们常说的“浅拷贝”，只复制基本类型的数据，引用类型的数据只复制了引用的地址，引用的对象并没有复制，在新的对象中修改引用类型的数据会影响原对象中的引用。

  1. 对于基本类型，拷贝其值

  2. 对于引用类型，拷贝其引用，但引用的对象是同一个

    浅拷贝-基本类型

    基本类型全拷贝，无影响 ```java //具体原型类 class Prototype implements Cloneable {

    //具有代表性类型的属性 private Integer i;//基本类型 private String s;//字符串类型

    @Override protected Object clone() throws CloneNotSupportedException {

    1.  return super.clone();

    }

    //构造方法 public Prototype(Integer i, String s) {

    1.  this.i = i;
    2.  this.s = s;

    }

    //—-geter和seter方法 public Integer getI() {

    1.  return i;

    }

    public void setI(Integer i) {

    1.  this.i = i;

    }

    public String getS() {

    1.  return s;

    }

    public void setS(String s) {

    1.  this.s = s;

    }

  1. //重写toString方法 方便查看对象
  2. @Override
  3. public String toString() {
  4.     return "Prototype{" +
  5.             "i=" + i +
  6.             ", s='" + s + '\'' +
  7.             '}';
  8. }

}

//测试类 public class PrototypeTest { public static void main(String[] args) throws InterruptedException, CloneNotSupportedException { Prototype p1 = new Prototype(1, “对象1”); Prototype p2 = (Prototype) p1.clone();

  1.     System.out.println("p1 == p2:" + (p1 == p2));
  2.     System.out.println("p1:" + p1);
  3.     System.out.println("p2:" + p2);
  5.     //输出：
  6.     //p1 == p2:false
  7.     //p1:Prototype{i=1, s='对象1'}
  8.     //p2:Prototype{i=1, s='对象1'}
  9. }

}

  1. <a name="AsCtP"></a>
  2. ## 浅拷贝-引用对象
  3. 在刚才的类的集成上增加一个引用对象 Other
  4. ```java
  5. //具体原型类
  6. class Prototype implements Cloneable {
  8.     //具有代表性类型的属性
  9.     private Integer i;//基本类型
  10.     private String s;//字符串类型
  11.     private Other other;//引用类型
  13.     @Override
  14.     protected Object clone() throws CloneNotSupportedException {
  15.         return super.clone();
  16.     }
  18.     //构造方法
  19.     public Prototype(Integer i, String s, Other other) throws InterruptedException {
  20.         this.i = i;
  21.         this.s = s;
  22.         this.other = other;
  23.     }
  25.     //---geter和seter方法
  26.     public Integer getI() {
  27.         return i;
  28.     }
  30.     public void setI(Integer i) {
  31.         this.i = i;
  32.     }
  34.     public String getS() {
  35.         return s;
  36.     }
  38.     public void setS(String s) {
  39.         this.s = s;
  40.     }
  42.     public Other getOther() {
  43.         return other;
  44.     }
  46.     public void setOther(Other other) {
  47.         this.other = other;
  48.     }
  51.     //重写toString方法 方便查看对象
  52.     @Override
  53.     public String toString() {
  54.         return "Prototype{" +
  55.                 "i=" + i +
  56.                 ", s='" + s + '\'' +
  57.                 ", other=" + other +
  58.                 '}';
  59.     }
  61. }
  63. class Other {
  64.     private int id;
  65.     private String name;
  68.     public Other(int id, String name) {
  69.         this.id = id;
  70.         this.name = name;
  71.     }
  73.     public int getId() {
  74.         return id;
  75.     }
  77.     public void setId(int id) {
  78.         this.id = id;
  79.     }
  81.     public String getName() {
  82.         return name;
  83.     }
  85.     public void setName(String name) {
  86.         this.name = name;
  87.     }
  89.     @Override
  90.     public String toString() {
  91.         return "Other{" +
  92.                 "id=" + id +
  93.                 ", name='" + name + '\'' +
  94.                 '}';
  95.     }
  96. }
  98. //测试类
  99. public class PrototypeTest {
  100.     public static void main(String[] args) throws InterruptedException, CloneNotSupportedException, IOException, ClassNotFoundException {
  101.         Prototype p1 = new Prototype(1, "对象1", new Other(11, "对象11"));
  102.         Prototype p2 = (Prototype) p1.clone();
  104.         Other other1 = p1.getOther();
  105.         Other other2 = p2.getOther();
  107.         System.out.println("p1 == p2:" + (p1 == p2));
  108.         System.out.println(p1);
  109.         System.out.println(p2);
  110.         System.out.println("sub1 == sub2:" + (other1 == other2));
  111.         System.out.println("sub1:" + other1);
  112.         System.out.println("sub2:" + other2);
  114.         p1.getOther().setId(3333);
  115.         System.out.println(p1);
  116.         System.out.println(p2);
  118.         //不显示指定clone()方法 则为浅拷贝
  119.         //输出：
  120.         //p1 == p2:false
  121.         //Prototype{i=1, s='对象1', other=Other{id=11, name='对象11'}}
  122.         //Prototype{i=1, s='对象1', other=Other{id=11, name='对象11'}}
  123.         //sub1 == sub2:true
  124.         //sub1:Other{id=11, name='对象11'}
  125.         //sub2:Other{id=11, name='对象11'}
  126.         //Prototype{i=1, s='对象1', other=Other{id=3333, name='对象11'}}
  127.         //Prototype{i=1, s='对象1', other=Other{id=3333, name='对象11'}}
  128.     }
  130. }

深拷贝-重写clone()方式

  • 所有的类都需要实现Cloneable，并显示指定clone()方法

  • 核心代码

    2.   @Override
    3.   protected Object clone() throws CloneNotSupportedException {
    4.       Prototype prototype = (Prototype) super.clone();
    5.       //需要显示指定所有引用对象的clone()方法
    6.       prototype.other = (Other) other.clone();
    7.       return prototype;
    8.   }

    ```java //具体原型类 class Prototype implements Cloneable {

    //具有代表性类型的属性 private Integer i;//基本类型 private String s;//字符串类型 private Other other;//引用类型

    @Override protected Object clone() throws CloneNotSupportedException {

    1.   Prototype prototype = (Prototype) super.clone();
    2.   //需要显示指定所有引用对象的clone()方法
    3.   prototype.other = (Other) other.clone();
    4.   return prototype;

    }

    //构造方法 public Prototype(Integer i, String s, Other other) throws InterruptedException {

    1.   this.i = i;
    2.   this.s = s;
    3.   this.other = other;

    }

    //—-geter和seter方法 public Integer getI() {

    1.   return i;

    }

    public void setI(Integer i) {

    1.   this.i = i;

    }

    public String getS() {

    1.   return s;

    }

    public void setS(String s) {

    1.   this.s = s;

    }

    public Other getOther() {

    1.   return other;

    }

    public void setOther(Other other) {

    1.   this.other = other;

    }

  1. //重写toString方法 方便查看对象
  2. @Override
  3. public String toString() {
  4.     return "Prototype{" +
  5.             "i=" + i +
  6.             ", s='" + s + '\'' +
  7.             ", other=" + other +
  8.             '}';
  9. }

}

class Other implements Cloneable { private int id; private String name;

  1. @Override
  2. protected Object clone() throws CloneNotSupportedException {
  3.     return super.clone();
  4. }
  6. public Other(int id, String name) {
  7.     this.id = id;
  8.     this.name = name;
  9. }
  11. public int getId() {
  12.     return id;
  13. }
  15. public void setId(int id) {
  16.     this.id = id;
  17. }
  19. public String getName() {
  20.     return name;
  21. }
  23. public void setName(String name) {
  24.     this.name = name;
  25. }
  27. @Override
  28. public String toString() {
  29.     return "Other{" +
  30.             "id=" + id +
  31.             ", name='" + name + '\'' +
  32.             '}';
  33. }

}

//测试类 public class PrototypeTest { public static void main(String[] args) throws InterruptedException, CloneNotSupportedException, IOException, ClassNotFoundException { Prototype p1 = new Prototype(1, “对象1”, new Other(11, “对象11”)); Prototype p2 = (Prototype) p1.clone();

  1.     Other other1 = p1.getOther();
  2.     Other other2 = p2.getOther();
  4.     System.out.println("p1 == p2:" + (p1 == p2));
  5.     System.out.println(p1);
  6.     System.out.println(p2);
  7.     System.out.println("sub1 == sub2:" + (other1 == other2));
  8.     System.out.println("sub1:" + other1);
  9.     System.out.println("sub2:" + other2);
  11.     p1.getOther().setId(3333);
  12.     System.out.println(p1);
  13.     System.out.println(p2);
  15.     //显示指定clone()方法 则为深拷贝
  16.     //输出：
  17.     //p1 == p2:false
  18.     //Prototype{i=1, s='对象1', other=Other{id=11, name='对象11'}}
  19.     //Prototype{i=1, s='对象1', other=Other{id=11, name='对象11'}}
  20.     //sub1 == sub2:false
  21.     //sub1:Other{id=11, name='对象11'}
  22.     //sub2:Other{id=11, name='对象11'}
  23.     //Prototype{i=1, s='对象1', other=Other{id=3333, name='对象11'}}
  24.     //Prototype{i=1, s='对象1', other=Other{id=11, name='对象11'}}
  25. }

}

  1. **个人的理解是Java中定义的clone没有深浅之分，都是统一的调用Object的clone方法。为什么会有深克隆的概念？是由于我们在实现的过程中刻意的嵌套了clone方法的调用。也就是说深克隆就是在需要克隆的对象类型的类中全部实现克隆方法。就像是toString方法一样。**<br />总结：<br />1.浅克隆：只复制基本类型的数据，引用类型的数据只复制了引用的地址，引用的对象并没有复制，在新的对象中修改引用类型的数据会影响原对象中的引用。<br />2.深克隆：是在引用类型的类中也实现了clone，是clone的嵌套，复制后的对象与原对象之间完全不会影响。<br />4.使用clone实现的深克隆其实是浅克隆中嵌套了浅克隆，与toString方法类似<br />_
  2. <a name="drDHE"></a>
  3. ## 深拷贝-序列化方式
  4. 使用对象序列化方式，把一个对象写入内存，然后从内存重写读取，拷贝出另一个对象，也可以实现深拷贝。
  5. ```java
  6. //具体原型类
  7. class Prototype implements Serializable {
  9.     //具有代表性类型的属性
  10.     private Integer i;//基本类型
  11.     private String s;//字符串类型
  12.     private Other other;//引用类型
  15.     //构造方法
  16.     public Prototype(Integer i, String s, Other other) {
  17.         this.i = i;
  18.         this.s = s;
  19.         this.other = other;
  20.     }
  22.     //---geter和seter方法
  23.     public Integer getI() {
  24.         return i;
  25.     }
  27.     public void setI(Integer i) {
  28.         this.i = i;
  29.     }
  31.     public String getS() {
  32.         return s;
  33.     }
  35.     public void setS(String s) {
  36.         this.s = s;
  37.     }
  39.     public Other getOther() {
  40.         return other;
  41.     }
  43.     public void setOther(Other other) {
  44.         this.other = other;
  45.     }
  48.     //重写toString方法 方便查看对象
  49.     @Override
  50.     public String toString() {
  51.         return "Prototype{" +
  52.                 "i=" + i +
  53.                 ", s='" + s + '\'' +
  54.                 ", other=" + other +
  55.                 '}';
  56.     }
  58. }
  60. class Other implements Serializable {
  61.     private int id;
  62.     private String name;
  64.     public Other(int id, String name) {
  65.         this.id = id;
  66.         this.name = name;
  67.     }
  69.     public int getId() {
  70.         return id;
  71.     }
  73.     public void setId(int id) {
  74.         this.id = id;
  75.     }
  77.     public String getName() {
  78.         return name;
  79.     }
  81.     public void setName(String name) {
  82.         this.name = name;
  83.     }
  85.     @Override
  86.     public String toString() {
  87.         return "Other{" +
  88.                 "id=" + id +
  89.                 ", name='" + name + '\'' +
  90.                 '}';
  91.     }
  92. }
  94. //测试类
  95. public class PrototypeTest {
  96.     public static void main(String[] args) throws InterruptedException, CloneNotSupportedException, IOException, ClassNotFoundException {
  97.         //实现深拷贝
  98.         Prototype p1 = new Prototype(1, "对象1", new Other(11, "对象11"));
  99.         //将对象写入内存
  100.         ByteArrayOutputStream bos = new ByteArrayOutputStream();
  101.         new ObjectOutputStream(bos).writeObject(p1);
  102.         //从内存读取对象
  103.         Prototype p2 = (Prototype) new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray())).readObject();
  104.         System.out.println();
  106.         System.out.println("p1 == p2:" + (p1 == p2));
  107.         System.out.println(p1);
  108.         System.out.println(p2);
  110.         Other other1 = p1.getOther();
  111.         Other other2 = p2.getOther();
  112.         System.out.println("sub1 == sub2:" + (other1 == other2));//深拷贝 引用对象也是重新拷贝一个新的对象
  113.         System.out.println("sub1:" + other1);
  114.         System.out.println("sub2:" + other2);
  116.         p1.getOther().setId(3333);
  117.         System.out.println(p1);
  118.         System.out.println(p2);
  119.         //输出：
  120.         //p1 == p2:false
  121.         //Prototype{i=1, s='对象1', other=Other{id=3333, name='对象11'}}
  122.         //Prototype{i=1, s='对象1', other=Other{id=11, name='对象11'}}
  123.         //sub1 == sub2:false
  124.         //sub1:Other{id=3333, name='对象11'}
  125.         //sub2:Other{id=11, name='对象11'}
  126.         //Prototype{i=1, s='对象1', other=Other{id=3333, name='对象11'}}
  127.         //Prototype{i=1, s='对象1', other=Other{id=11, name='对象11'}}
  128.     }
  130. }
  • 所有类都实现Serializable接口，使其可序列化

  • 对象写入内存

    1. ByteArrayOutputStream bos = new ByteArrayOutputStream();
    2. new ObjectOutputStream(bos).writeObject(p1);

  • 复制对象的过程就是反序列化的过程

    1. Prototype p2 = (Prototype) new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray())).readObject();

    深拷贝-耗时测试

    深拷贝可以节省时间？做个测试
    模拟创建对象的时候耗时操作

    1. //模拟创建对象耗时操作
    2. try {
    3.   Thread.sleep(3_000);
    4. } catch (InterruptedException e) {
    5.   e.printStackTrace();
    6. }

    ```java //具体原型类 class Prototype implements Serializable {

    //具有代表性类型的属性 private Integer i;//基本类型 private String s;//字符串类型 private Other other;//引用类型

  1. //构造方法
  2. public Prototype(Integer i, String s, Other other) {
  3.     this.i = i;
  4.     this.s = s;
  5.     this.other = other;
  7.     //模拟创建对象耗时操作
  8.     try {
  9.         Thread.sleep(3_000);
  10.     } catch (InterruptedException e) {
  11.         e.printStackTrace();
  12.     }
  13. }
  15. //---geter和seter方法
  16. public Integer getI() {
  17.     return i;
  18. }
  20. public void setI(Integer i) {
  21.     this.i = i;
  22. }
  24. public String getS() {
  25.     return s;
  26. }
  28. public void setS(String s) {
  29.     this.s = s;
  30. }
  32. public Other getOther() {
  33.     return other;
  34. }
  36. public void setOther(Other other) {
  37.     this.other = other;
  38. }
  41. //重写toString方法 方便查看对象
  42. @Override
  43. public String toString() {
  44.     return "Prototype{" +
  45.             "i=" + i +
  46.             ", s='" + s + '\'' +
  47.             ", other=" + other +
  48.             '}';
  49. }

}

class Other implements Serializable { private int id; private String name;

  1. public Other(int id, String name) {
  2.     this.id = id;
  3.     this.name = name;
  4. }
  6. public int getId() {
  7.     return id;
  8. }
  10. public void setId(int id) {
  11.     this.id = id;
  12. }
  14. public String getName() {
  15.     return name;
  16. }
  18. public void setName(String name) {
  19.     this.name = name;
  20. }
  22. @Override
  23. public String toString() {
  24.     return "Other{" +
  25.             "id=" + id +
  26.             ", name='" + name + '\'' +
  27.             '}';
  28. }

}

//测试类 public class PrototypeTest { public static void main(String[] args) throws InterruptedException, CloneNotSupportedException, IOException, ClassNotFoundException { long start1 = System.currentTimeMillis(); Prototype p1 = new Prototype(1, “对象1”, new Other(11, “对象11”)); long end1 = System.currentTimeMillis(); System.out.println(“new对象耗时：” + (end1 - start1)); //将对象写入内存 ByteArrayOutputStream bos = new ByteArrayOutputStream(); new ObjectOutputStream(bos).writeObject(p1);

  1.     //从内存读取对象
  2.     long start2 = System.currentTimeMillis();
  3.     Prototype p2 = (Prototype) new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray())).readObject();
  4.     long end2 = System.currentTimeMillis();
  5.     System.out.println("内存拷贝对象耗时：" + (end2 - start2));
  6. }
  7. //输出：
  8. //new对象耗时：3002
  9. //内存拷贝对象耗时：35

``` 总结：

1.浅克隆：只复制基本类型的数据，引用类型的数据只复制了引用的地址，引用的对象并没有复制，在新的对象中修改引用类型的数据会影响原对象中的引用。
2.深克隆：是在引用类型的类中也实现了clone，是clone的嵌套，复制后的对象与原对象之间完全不会影响。
3.使用序列化也能完成深复制的功能：对象序列化后写入流中，此时也就不存在引用什么的概念了，再从流中读取，生成新的对象，新对象和原对象之间也是完全互不影响的。
4.使用clone实现的深克隆其实是浅克隆中嵌套了浅克隆，与toString方法类似