https://www.runoob.com/design-pattern/prototype-pattern.html

1. 概念

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

2. 介绍

意图：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
主要解决：在运行期建立和删除原型。
何时使用：
1、当一个系统应该独立于它的产品创建，构成和表示时。
2、当要实例化的类是在运行时刻指定时，例如，通过动态装载。
3、为了避免创建一个与产品类层次平行的工厂类层次时。
4、当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。
如何解决：利用已有的一个原型对象，快速地生成和原型对象一样的实例。
关键代码： 1、实现克隆操作，在 JAVA 继承 Cloneable，重写 clone()，在 .NET 中可以使用 Object 类的 MemberwiseClone() 方法来实现对象的浅拷贝或通过序列化的方式来实现深拷贝。 2、原型模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它同样要求这些”易变类”拥有稳定的接口。
应用实例： 1、细胞分裂。 2、JAVA 中的 Object clone() 方法。
优点： 1、性能提高。 2、逃避构造函数的约束。
缺点：
1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。
2、必须实现 Cloneable 接口。
使用场景：
1、资源优化场景。
2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
3、性能和安全要求的场景。
4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
5、一个对象多个修改者的场景。
6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂 方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。
注意事项：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。

3. 代码

我们将创建一个抽象类 Shape 和扩展了 Shape 类的实体类。下一步是定义类 ShapeCache，该类把 shape 对象存储在一个 Hashtable 中，并在请求的时候返回它们的克隆。
PrototypePatternDemo 类使用 ShapeCache 类来获取 Shape 对象。
image.png

总的shape类

  1. public abstract class Shape implements Cloneable{
  2.     //形状id
  3.     private String id;
  4.     //形状类型
  5.     protected String type;
  6.     //画
  7.     abstract void draw();
  9.     public String getType(){
  10.         return type;
  11.     }
  13.     public String getId() {
  14.         return id;
  15.     }
  17.     public void setId(String id) {
  18.         this.id = id;
  19.     }
  21.     @Override
  22.     public Object clone() {
  23.         Object clone = null;
  24.         try {
  25.             clone = super.clone();
  26.         } catch (CloneNotSupportedException e) {
  27.             e.printStackTrace();
  28.         }
  29.         return clone;
  30.     }
  31. }

具体子类

  1. public class Circle extends Shape{
  3.     public Circle() {
  4.         type = "圆形";
  5.     }
  7.     @Override
  8.     public void draw() {
  9.         System.out.println("画一个圆形");
  10.     }
  11. }
  14. public class Rectangle extends Shape{
  15.     public Rectangle() {
  16.         type = "长方形";
  17.     }
  19.     @Override
  20.     public void draw() {
  21.         System.out.println("画一个长方形");
  22.     }
  23. }
  25. public class Square extends Shape{
  27.     public Square() {
  28.         type = "正方形";
  29.     }
  31.     @Override
  32.     public void draw() {
  33.         System.out.println("画一个正方形");
  34.     }
  35. }

缓存类

  1. //缓存图形
  2. public class ShapeCache {
  3.     //添加进
  4.     private static Hashtable<String, Shape> shapeMap
  5.             = new Hashtable<String, Shape>();
  7.     //在缓存中找出类
  8.     public static Shape getShape(String shapeId) {
  9.         Shape cachedShape = shapeMap.get(shapeId);
  10.         return (Shape) cachedShape.clone();
  11.     }
  13.     //这一步，我们可以理解成从数据库中把查询出来的类加到map中去
  14.     public static void loadCache() {
  15.         Circle circle = new Circle();
  16.         circle.setId("1");
  17.         shapeMap.put(circle.getId(),circle);
  19.         Square square = new Square();
  20.         square.setId("2");
  21.         shapeMap.put(square.getId(),square);
  23.         Rectangle rectangle = new Rectangle();
  24.         rectangle.setId("3");
  25.         shapeMap.put(rectangle.getId(),rectangle);
  26.     }
  27. }

测试类

  1. public class PrototypePatternDemo {
  2.     public static void main(String[] args) {
  3.         //先从数据库加载到缓存中
  4.         ShapeCache.loadCache();
  6.         //值得注意的是：这里的形状是从缓存map中拿出来的
  7.         Shape clonedShape = (Shape) ShapeCache.getShape("1");
  8.         System.out.println("Shape : " + clonedShape.getType());
  10.         Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
  11.         System.out.println("Shape : " + clonedShape2.getType());
  13.         Shape clonedShape3 = (Shape) ShapeCache.getShape("3");
  14.         System.out.println("Shape : " + clonedShape3.getType());
  16.         //Shape : 圆形
  17.         //Shape : 正方形
  18.         //Shape : 长方形
  19.     }
  20. }

4. 谈谈clone

clone：克隆，字面意思就是根据已有对象创建出一个新的一模一样的对象

https://blog.csdn.net/riemann_/article/details/87217229?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163022812916780274139081%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=163022812916780274139081&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-87217229.first_rank_v2_pc_rank_v29&utm_term=%E6%B7%B1%E6%8B%B7%E8%B4%9D%E5%92%8C%E6%B5%85%E6%8B%B7%E8%B4%9D&spm=1018.2226.3001.4187

4.1 浅拷贝

被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。即对象的浅拷贝会对“主”对象进行拷贝，但不会复制主对象里面的对象。”里面的对象“会在原来的对象和它的副本之间共享。
简而言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。
image.png

  1. public class Teacher implements Cloneable{
  2.         private String name;
  3.         private int age;
  6.         public String getName() {
  7.             return name;
  8.         }
  10.         public void setName(String name) {
  11.             this.name = name;
  12.         }
  14.         public int getAge() {
  15.             return age;
  16.         }
  18.         public void setAge(int age) {
  19.             this.age = age;
  20.         }
  21.     }
  24. public class Student implements Cloneable{
  26.     private Teacher teacher;
  27.     private String name;
  29.     @Override
  30.     public String toString() {
  31.         return "Student{" +
  32.                 "teacher=" + teacher +
  33.                 ", name='" + name + '\'' +
  34.                 '}';
  35.     }
  37.     public Teacher getTeacher() {
  38.         return teacher;
  39.     }
  41.     public void setTeacher(Teacher teacher) {
  42.         this.teacher = teacher;
  43.     }
  45.     public String getName() {
  46.         return name;
  47.     }
  49.     public void setName(String name) {
  50.         this.name = name;
  51.     }
  53.     public Student() {
  54.     }
  56.     @Override
  57.     public Object clone() throws CloneNotSupportedException {
  58.         Object object = super.clone();
  59.         return object;
  60.     }
  61. }
  1. public class ShallowClone {
  2.     public static void main(String[] args) throws Exception {
  3.         Teacher teacher = new Teacher();
  4.         teacher.setName("修改前");
  5.         teacher.setAge(18);
  7.         Student student1 = new Student();
  8.         student1.setName("李四");
  9.         student1.setTeacher(teacher);
  11.         Student student2 = (Student) student1.clone();
  12.         System.out.println("=============克隆====================");
  13.         System.out.println(student2.getName()); //李四
  14.         System.out.println(student2.getTeacher().getName());//修改前
  15.         System.out.println(student2.getTeacher().getAge());//18
  17.         System.out.println("==============修改后==================");
  18.         teacher.setName("修改后");
  19.         System.out.println(student2.getTeacher().getName());//修改后
  20.         System.out.println(student2.getTeacher().getAge());//18
  21.     }
  22. }

可以看到修改了student1里面的teacher，student2里面的teacher也变了，证明克隆过后两个stu的teacher指向的是同一个。这就是浅拷贝

4.2 深拷贝

下面例子可以看到，修改了第一个stu的teacher信息，第二个stu的teacher信息不会变

  1. public class ShallowClone {
  2.     public static void main(String[] args) throws Exception {
  3.         Teacher teacher = new Teacher();
  4.         teacher.setName("修改前");
  5.         teacher.setAge(18);
  7.         Student student1 = new Student();
  8.         student1.setName("李四");
  9.         student1.setTeacher(teacher);
  11.         Student student2 = (Student) student1.clone();
  12.         System.out.println("=============克隆====================");
  13.         System.out.println(student2.getName()); //李四
  14.         System.out.println(student2.getTeacher().getName());//修改前
  15.         System.out.println(student2.getTeacher().getAge());//18
  17.         System.out.println("==============修改后==================");
  18.         teacher.setName("修改后");
  19.         System.out.println(student1.getTeacher().getName());//修改后
  20.         System.out.println(student2.getTeacher().getName());//修改前
  21.     }
  22. }
  25. public class Student implements Cloneable{
  27.     private Teacher teacher;
  28.     private String name;
  30.     @Override
  31.     public String toString() {
  32.         return "Student{" +
  33.                 "teacher=" + teacher +
  34.                 ", name='" + name + '\'' +
  35.                 '}';
  36.     }
  38.     public Teacher getTeacher() {
  39.         return teacher;
  40.     }
  42.     public void setTeacher(Teacher teacher) {
  43.         this.teacher = teacher;
  44.     }
  46.     public String getName() {
  47.         return name;
  48.     }
  50.     public void setName(String name) {
  51.         this.name = name;
  52.     }
  54.     public Student() {
  55.     }
  57.     @Override
  58.     public Object clone() throws CloneNotSupportedException {
  59.         // 改为深复制：
  60.         Student student = (Student) super.clone();
  61.         // 本来是浅复制，现在将Teacher对象复制一份并重新set进来,这时候两个teacher就是不同的了
  62.         student.setTeacher((Teacher) student.getTeacher().clone());
  63.         return student;
  64.     }
  65. }
  1. public class ShallowClone {
  2.     public static void main(String[] args) throws Exception {
  3.         Teacher teacher = new Teacher();
  4.         teacher.setName("修改前");
  5.         teacher.setAge(18);
  7.         Student student1 = new Student();
  8.         student1.setName("李四");
  9.         student1.setTeacher(teacher);
  11.         Student student2 = (Student) student1.clone();
  12.         System.out.println("=============克隆====================");
  13.         System.out.println(student2.getName()); //李四
  14.         System.out.println(student2.getTeacher().getName());//修改前
  15.         System.out.println(student2.getTeacher().getAge());//18
  17.         System.out.println("==============修改后==================");
  18.         teacher.setName("修改后");
  19.         System.out.println(student1.getTeacher().getName());//修改后
  20.         System.out.println(student2.getTeacher().getName());//修改前
  21.     }
  22. }

image.png