场景 如果一个对象，我们希望拷贝一个这个对象，就是弄出来这个类的另外一个实例，实例的属性跟之前的实例是一模一样的

1.常规

  2. package com.example.demo.pattern.prototype;
  3. /**
  4.  * @author chenchao
  5.  * @date 2021/11/9
  6.  */
  7. public class WithoutPrototypePatternDemo {
  9.     public static void main(String[] args) {
  10.         // 手头有这么一个对象，需要进行拷贝
  11.         Product product = new Product("测试产品", new Component("测试组件"));  
  12.         // 手动来拷贝
  13.         Product copyProduct = new Product(product.getName(), product.getComponent());
  14.         System.out.println(copyProduct);  
  16.         // 问题是什么？
  17.         // 代码的拷贝逻辑，是每个要拷贝的调用方自己来实现的
  18.         // 相同的拷贝逻辑会分散在很多不同的地方，如果拷贝逻辑改变了，多个调用的地方都要修改代码
  19.         // 可维护性、可扩展性，很差
  20.     }
  22.     public static class  Component {
  24.         private String name;
  26.         public Component(String name) {
  27.             super();
  28.             this.name = name;
  29.         }
  31.         public String getName() {
  32.             return name;
  33.         }
  35.         public void setName(String name) {
  36.             this.name = name;
  37.         }
  39.         @Override
  40.         public String toString() {
  41.             return "Component [name=" + name + "]";
  42.         }
  44.     }
  46.     public static class Product {
  48.         private String name;
  49.         private Component component;
  51.         public Product(String name, Component component) {
  52.             super();
  53.             this.name = name;
  54.             this.component = component;
  55.         }
  57.         public String getName() {
  58.             return name;
  59.         }
  60.         public void setName(String name) {
  61.             this.name = name;
  62.         }
  63.         public Component getComponent() {
  64.             return component;
  65.         }
  66.         public void setComponent(Component component) {
  67.             this.component = component;
  68.         }
  70.         @Override
  71.         public String toString() {
  72.             return "Product [name=" + name + ", component=" + component + "]";
  73.         }
  75.     }
  77. }

2.原型模式

  1. package com.example.demo.pattern.prototype;
  2. /**
  3.  * @author chenchao
  4.  * @date 2021/11/9
  5.  */
  6. public class PrototypePatternDemo {
  8.     public static void main(String[] args) {
  9.         try {
  10.             Product product = new Product("测试产品", new Component("测试组件"));  
  11.             Product copyProduct = (Product) product.clone();
  12.             System.out.println(copyProduct); 
  13.         } catch (Exception e) {
  14.             e.printStackTrace();
  15.         }
  17.         // 原型模式，就是在要拷贝的类里实现一个clone()方法，自己拷贝自己
  18.         // 拷贝的时候，就两个概念，浅拷贝，深拷贝
  20.         // 很多地方要克隆这个对象，不要自己维护克隆的逻辑，即使克隆逻辑修改了，只要在clone()方法里面修改
  21.     }
  23.     public static class  Component {
  25.         private String name;
  27.         public Component(String name) {
  28.             super();
  29.             this.name = name;
  30.         }
  32.         public String getName() {
  33.             return name;
  34.         }
  36.         public void setName(String name) {
  37.             this.name = name;
  38.         }
  40.         @Override
  41.         public String toString() {
  42.             return "Component [name=" + name + "]";
  43.         }
  45.         @Override
  46.         protected Object clone() throws CloneNotSupportedException {
  47.             return new Component(getName()); 
  48.         }
  50.     }
  52.     public static class Product {
  54.         private String name;
  55.         private Component component;
  57.         public Product(String name, Component component) {
  58.             super();
  59.             this.name = name;
  60.             this.component = component;
  61.         }
  63.         public String getName() {
  64.             return name;
  65.         }
  66.         public void setName(String name) {
  67.             this.name = name;
  68.         }
  69.         public Component getComponent() {
  70.             return component;
  71.         }
  72.         public void setComponent(Component component) {
  73.             this.component = component;
  74.         }
  76.         @Override
  77.         public String toString() {
  78.             return "Product [name=" + name + ", component=" + component + "]";
  79.         }
  81.         @Override
  82.         protected Object clone() throws CloneNotSupportedException {
  83.             // 浅拷贝，就是我们现在的一个实现
  84.             // 就是仅仅简单的对当前所有的变量进行一个拷贝
  85. //            return new Product(getName(), getComponent());
  87.             // 深考别，递归对自己引用的对象也进行拷贝
  88.             return new Product(getName(), (Component)getComponent().clone());
  89.         }
  91.     }
  93. }

3.说明

原型模式，顾名思义，其实说白了，就是让一个对象可以自己拷贝自己，对象把自己当成一个原型，然后提供一个方法出去，外部要一个对象的克隆和拷贝，直接就copy一份就可以了，但是这里要记住深拷贝和浅拷贝的区别

因为一个对象可能还持有别的对象的引用，浅拷贝就是不管引用的其他对象了；深拷贝就是将引用的对象也一起拷贝一份；一般原型模式都是要支持深拷贝的

而且其实一般实现原型模式的时候，直接是通过覆盖Object类的clone()方法即可，在里面实现自己的拷贝逻辑就可以了

使用原型模式比较好的一点，就是如果别人要拷贝你的对象，不需要调用方自己实现拷贝逻辑，将拷贝逻辑放在对象自己身体里就可以了，对外面调用都是透明的