【原型设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

简介

原型模式（Prototype Pattern）是一种创建型设计模式，使你能够复制已有对象，而无需使代码依赖它们所属的类，同时又能保证性能。
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。
如果你需要复制一些对象，同时又希望代码独立于这些对象所属的具体类，可以使用原型模式。
作用

• 利用已有的一个原型对象，快速地生成和原型对象一样的实例。
  
• 跳过构造函数的约束，便于提升性能。
  

实现步骤

• 创建原型接口，并声明克隆方法。
  
• 使用new运算符调用原型版本的构造函数。
  
• 将子类构造函数的直接调用，替换为对原型工厂方法的调用。
  

UML

 
Java代码

基础原型抽象类

1. // Shape.java 基础抽象类
2. public abstract class Shape implements Cloneable {
4.   private int width;
5.   private int height;
6.   private String color = "";
7.   protected String type;
9.   public Shape() {
11.   }
13.   public String getType() {
14.     return type;
15.   }
17.   // 抽象方法，子类覆盖
18.   public abstract void draw();
20.   public void setWidth(int width) {
21.     this.width = width;
22.   }
24.   public int getWidth() {
25.     return this.width;
26.   }
28.   public int getHeight() {
29.     return this.height;
30.   }
32.   public void setHeight(int height) {
33.     this.height = height;
34.   }
36.   public void setColor(String color) {
37.     this.color = color;
38.   }
40.   public String getColor() {
41.     return this.color;
42.   }
44.   // 克隆方法
45.   public Object clone() {
46.     Object clone = null;
47.     try {
48.       clone = super.clone();
49.     } catch (CloneNotSupportedException e) {
50.       e.printStackTrace();
51.     }
52.     return clone;
53.   }
55.   @Override
56.   public String toString() {
57.     return String.format("{width = %s, height = %s, type = %s, color = %s }",
58.         this.width, this.height, this.type, this.color);
59.   }
60. }

复制代码

具体原型者

1. // Circle.java 具体原型类，克隆方法会创建一个新对象并将其传递给构造函数。
2. public class Circle extends Shape {
3.   public Circle() {
4.     super();
5.     type = "Circle";
6.   }
8.   @Override
9.   public void draw() {
10.     System.out.println("Circle::draw() method.");
11.   }
12. }

复制代码

1. // Rectangle.java 具体原型类，克隆方法会创建一个新对象并将其传递给构造函数。
2. public class Rectangle extends Shape {
3.   public Rectangle() {
4.     super();
5.     type = "Rectangle";
6.   }
8.   @Override
9.   public void draw() {
10.      System.out.println("Rectangle::draw() method.");
11.   }
12. }

复制代码

1. // 具体原型类，克隆方法会创建一个新对象并将其传递给构造函数。
2. public class Square extends Shape {
3.   public Square() {
4.     super();
5.     type = "Square";
6.   }
8.   @Override
9.   public void draw() {
10.     System.out.println("Square::draw() method.");
11.   }
12. }

复制代码

客户使用类

1. // Application.java 客户调用方
2. public class Application {
4.   public List<Shape> shapes = new ArrayList<Shape>();
6.   public Application() {
7.   }
9.   public void addToShapes() {
10.     Circle circle = new Circle();
11.     circle.setWidth(10);
12.     circle.setHeight(20);
13.     circle.setColor("red");
14.     shapes.add(circle);
16.     // 添加clone
17.     Circle anotherCircle = (Circle) circle.clone();
18.     anotherCircle.setColor("pink");
19.     shapes.add(anotherCircle);
20.     // 变量 `anotherCircle（另一个圆）`与 `circle（圆）`对象的内容完全一样。
22.     Rectangle rectangle = new Rectangle();
23.     rectangle.setWidth(99);
24.     rectangle.setHeight(69);
25.     rectangle.setColor("green");
26.     shapes.add(rectangle);
27.     // 添加clone
28.     shapes.add((Shape) rectangle.clone());
29.   }
31.   // 直接取出
32.   public Shape getShape(Integer index) {
33.     return this.shapes.get(index);
34.   }
36.   // 取出时候clone
37.   public Shape getShapeClone(Integer index) {
38.     Shape shape = this.shapes.get(index);
39.     return (Shape) shape.clone();
40.   }
42.   public void printShapes() {
43.     for (int i = 0; i < this.shapes.size(); i++) {
44.       Shape shape = this.shapes.get(i);
45.       System.out.println("shape " + i + " : " + shape.toString());
46.     }
47.   }
49. }

复制代码

测试调用

1.     /**
2.      * 原型模式主要就是复制已有的对象，而无需实例化类，从而提升实例化对象时的性能
3.      * 其实就是复制实例的属性到新对象上，减少了执行构造的步骤
4.      */
5.     Application application = new Application();
6.     application.addToShapes();
7.     Shape shapeClone = application.getShapeClone(1);
8.     // 更改clone
9.     shapeClone.setColor("gray");
10.     System.out.println("shapeClone : " + shapeClone.toString());
11.     // 直接更改
12.     application.getShape(3).setColor("yellow");
13.     application.printShapes();
15.     // /*********************** 分割线 ******************************************/
16.     application.shapes.add(new Square());
17.     for (Shape shape : application.shapes) {
18.       shape.draw();
19.       System.out.println(shape.toString());
20.     }

复制代码

C代码

基础原型抽象类

1. // func.h 基础头文件
2. #include <stdio.h>
3. #include <ctype.h>
4. #include <stdlib.h>
5. #include <stdbool.h>
6. #include <string.h>
8. typedef struct Shape shape;
9. typedef struct Circle circle;
10. typedef struct Rectangle rectangle;
11. typedef struct Square square;
13. // 定义了Shape作为基础接口，以便各形状有统一类型
14. typedef struct Shape
15. {
16.     char name[50];
17.     int width;
18.     int height;
19.     char color[50];
20.     char category[50];
21.     void (*draw)(struct Shape *shape);
22.     struct Shape *(*clone)(struct Shape *shape);
23.     char *(*to_string)(struct Shape *shape);
24.     void (*set_width)(struct Shape *shape, int width);
25.     int (*get_width)(struct Shape *shape);
26.     void (*set_height)(struct Shape *shape, int height);
27.     int (*get_height)(struct Shape *shape);
28.     void (*set_color)(struct Shape *shape, char *color);
29.     char *(*get_color)(struct Shape *shape);
30.     void (*set_category)(struct Shape *shape, char *category);
31.     char *(*get_category)(struct Shape *shape);
32. } Shape;
33. Shape *shape_constructor(char *name);
35. typedef struct Circle
36. {
37.     char name[50];
38.     int width;
39.     int height;
40.     char color[50];
41.     char category[50];
42.     void (*draw)(struct Circle *shape);
43.     struct Circle *(*clone)(struct Circle *shape);
44.     char *(*to_string)(struct Circle *shape);
45.     void (*set_width)(struct Circle *shape, int width);
46.     int (*get_width)(struct Circle *shape);
47.     void (*set_height)(struct Circle *shape, int height);
48.     int (*get_height)(struct Circle *shape);
49.     void (*set_color)(struct Circle *shape, char *color);
50.     char *(*get_color)(struct Circle *shape);
51.     void (*set_category)(struct Circle *shape, char *category);
52.     char *(*get_category)(struct Circle *shape);
53. } Circle;
54. Circle *circle_constructor(char *name);
56. typedef struct Square
57. {
58.     char name[50];
59.     int width;
60.     int height;
61.     char color[50];
62.     char category[50];
63.     void (*draw)(struct Square *shape);
64.     struct Square *(*clone)(struct Square *shape);
65.     char *(*to_string)(struct Square *shape);
66.     void (*set_width)(struct Square *shape, int width);
67.     int (*get_width)(struct Square *shape);
68.     void (*set_height)(struct Square *shape, int height);
69.     int (*get_height)(struct Square *shape);
70.     void (*set_color)(struct Square *shape, char *color);
71.     char *(*get_color)(struct Square *shape);
72.     void (*set_category)(struct Square *shape, char *category);
73.     char *(*get_category)(struct Square *shape);
74. } Square;
75. Square *square_constructor(char *name);
77. typedef struct Rectangle
78. {
79.     char name[50];
80.     int width;
81.     int height;
82.     char color[50];
83.     char category[50];
84.     void (*draw)(struct Rectangle *shape);
85.     struct Rectangle *(*clone)(struct Rectangle *shape);
86.     char *(*string)(struct Rectangle *shape);
87.     void (*set_width)(struct Rectangle *shape, int width);
88.     int *(*get_width)(struct Rectangle *shape);
89.     void (*set_height)(struct Rectangle *shape, int height);
90.     int *(*get_height)(struct Rectangle *shape);
91.     void (*set_color)(struct Rectangle *shape, char *color);
92.     char *(*get_color)(struct Rectangle *shape);
93.     void (*set_category)(struct Rectangle *shape, char *category);
94.     char *(*get_category)(struct Rectangle *shape);
95. } Rectangle;
96. Rectangle *rectangle_constructor(char *name);
98. // 调用客户端
99. typedef struct Application
100. {
101.     struct Shape **shapes;
102.     int shapes_length;
103.     void (*add_to_shapes)(struct Application *app);
104.     void (*add_shape)(struct Application *app, Shape *shape);
105.     Shape *(*get_shape)(struct Application *app, int index);
106.     Shape **(*get_shapes)(struct Application *app);
107.     Shape *(*get_shape_clone)(struct Application *app, int index);
108.     void (*print_shapes)(struct Application *app);
109. } Application;
110. Application *application_constructor();

复制代码

1. // shape.c 基础类，供各种具体形状复用
2. #include "func.h"
4. // shape基础抽象类，供子类继承覆盖
5. // C没有抽象和继承，此处作为公共类存在
6. void shape_draw(Shape *shape)
7. {
8.   printf("\r\n Shape::draw()");
9. }
11. void shape_set_width(Shape *shape, int width)
12. {
13.   shape->width = width;
14. }
16. int shape_get_width(Shape *shape)
17. {
18.   return shape->width;
19. }
21. int shape_get_height(Shape *shape)
22. {
23.   return shape->height;
24. }
26. void shape_set_height(Shape *shape, int height)
27. {
28.   shape->height = height;
29. }
31. void shape_set_color(Shape *shape, char *color)
32. {
33.   strncpy(shape->color, color, 50);
34. }
36. char *shape_get_color(Shape *shape)
37. {
38.   return shape->color;
39. }
41. void shape_set_category(Shape *shape, char *category)
42. {
43.   strncpy(shape->category, category, 50);
44. }
46. char *shape_get_category(Shape *shape)
47. {
48.   return shape->category;
49. }
51. char *shape_to_string(Shape *shape)
52. {
53.   static char result[1024];
54.   sprintf(result, "[name = %s width = %d, height = %d, category = %s, color = %s]",
55.           shape->name, shape->width, shape->height, shape->category, shape->color);
56.   return result;
57. }
59. // 将指针指向同一内存的方式来实现clone
60. Shape *shape_clone(Shape *shape)
61. {
62.   Shape *copy = (Shape *)malloc(sizeof(Shape));
63.   memcpy(copy, shape, sizeof(Shape));
64.   strcat(copy->name, "(clone)");
65.   // printf("\r\n shape_clone: %s", copy->to_string(copy));
66.   return copy;
67. }
69. // 定义简单结构体，复制基本属性和draw函数
70. Shape *shape_clone2(Shape *shape)
71. {
72.   struct Shape copy = {
73.       .width = shape->width,
74.       .height = shape->height,
75.   };
76.   strcpy(copy.name, shape->name);
77.   strcat(copy.name, "[clone]");
78.   strcpy(copy.color, shape->color);
79.   strcpy(copy.category, shape->category);
80.   Shape *shape_copy = ©
81.   shape_copy->draw = shape->draw;
82.   // printf("\r\n shape_clone: %s", shape->to_string(shape_copy));
83.   return shape_copy;
84. }
86. Shape *shape_constructor(char *name)
87. {
88.   printf("\r\n shape_constructor() [构建Shape]");
89.   Shape *shape = (Shape *)malloc(sizeof(Shape));
90.   strncpy(shape->name, name, 50);
91.   shape->draw = &shape_draw;
92.   shape->clone = &shape_clone;
93.   shape->to_string = &shape_to_string;
94.   shape->set_width = &shape_set_width;
95.   shape->get_width = &shape_get_width;
96.   shape->set_height = &shape_set_height;
97.   shape->get_height = &shape_get_height;
98.   shape->set_color = &shape_set_color;
99.   shape->get_color = &shape_get_color;
100.   shape->set_category = &shape_set_category;
101.   shape->get_category = &shape_get_category;
102.   return shape;
103. }

复制代码

具体原型者

1. // circle.c 具体原型类，复用父类方法，实现自己的draw函数。
2. #include "func.h"
4. // 重新定义draw函数
5. void circle_draw(Circle *shape)
6. {
7.   printf("\r\n Circle::draw()");
8. }
10. Circle *circle_constructor(char *name)
11. {
12.   printf("\r\n shape_constructor() [构建Circle]");
13.   Shape *shape = (Shape *)shape_constructor(name);
14.   Circle *circle = (Circle *)shape;
15.   circle->draw = &circle_draw;
16.   return circle;
17. }

复制代码

1. // rectangle.c 具体原型类，复用父类方法，实现自己的draw函数。
2. #include "func.h"
4. // 重新定义draw函数
5. void rectangle_draw(Rectangle *shape)
6. {
7.   printf("\r\n Rectangle::draw()");
8. }
10. Rectangle *rectangle_constructor(char *name)
11. {
12.   printf("\r\n shape_constructor() [构建Rectangle]");
13.   Shape *shape = (Shape *)shape_constructor(name);
14.   Rectangle *rectangle = (Rectangle *)shape;
15.   rectangle->draw = &rectangle_draw;
16.   return rectangle;
17. }

复制代码

1. // square.c 具体原型类，复用父类方法，实现自己的draw函数。
2. #include "func.h"
4. // 重新定义draw函数
5. void square_draw(Square *shape)
6. {
7.   printf("\r\n Square::draw()");
8. }
10. Square *square_constructor(char *name)
11. {
12.   printf("\r\n shape_constructor() [构建Square]");
13.   Shape *shape = (Shape *)shape_constructor(name);
14.   Square *square = (Square *)shape;
15.   square->draw = &square_draw;
16.   return square;
17. }

复制代码

客户使用类

1. // application.c 客户调用方
2. #include "func.h"
4. void app_add_to_shapes(Application *app)
5. {
6.   Circle *circle = circle_constructor("circle");
7.   circle->set_category(circle, "Circle");
8.   circle->set_width(circle, 10);
9.   circle->set_height(circle, 20);
10.   circle->set_color(circle, "red");
11.   app->add_shape(app, (Shape *)circle);
13.   // 添加Clone
14.   Circle *another_circle = circle->clone(circle);
15.   another_circle->set_color(another_circle, "pink");
16.   app->add_shape(app, (Shape *)another_circle);
17.   // 变量 `another_circle（另一个圆）`与 `circle（圆）`对象的内容完全一样。
19.   Rectangle *rectangle = rectangle_constructor("rectangle");
20.   rectangle->set_category(rectangle, "Rectangle");
21.   rectangle->set_width(rectangle, 99);
22.   rectangle->set_height(rectangle, 69);
23.   rectangle->set_color(rectangle, "green");
24.   app->add_shape(app, (Shape *)rectangle);
25.   // 再添加一个clone
26.   app->add_shape(app, (Shape *)rectangle->clone(rectangle));
27. }
29. void app_add_shape(Application *app, Shape *shape)
30. {
31.   app->shapes_length += 1;
32.   Shape **new_shapes = (Shape **)calloc(app->shapes_length, sizeof(Shape));
33.   // 复制原有数组，并追加新内容到新数组
34.   for (int i = 0; i < app->shapes_length - 1; i++)
35.   {
36.     new_shapes[i] = app->shapes[i];
37.   }
38.   new_shapes[app->shapes_length - 1] = shape;
39.   free(app->shapes);
40.   // 指向新数组
41.   app->shapes = new_shapes;
42. }
44. Shape *app_get_shape(Application *app, int index)
45. {
46.   return app->shapes[index];
47. }
49. Shape **app_get_shapes(Application *app)
50. {
51.   return app->shapes;
52. }
54. Shape *app_get_shape_clone(Application *app, int index)
55. {
56.   Shape *shape = app->shapes[index];
57.   if (shape != NULL)
58.   {
59.     return shape->clone(shape);
60.   }
61.   return NULL;
62. }
64. void app_print_shapes(Application *app)
65. {
66.   for (int i = 0; i < app->shapes_length; i++)
67.   {
68.     Shape *shape = app->shapes[i];
69.     printf("\r\n shape%d: %s", i, shape->to_string(shape));
70.   }
71. }
73. // 给观察者绑定主题，同时把观察者添加到主题列表
74. Application *application_constructor()
75. {
76.   printf("\r\n application_constructor() [构建Application]");
77.   Application *app = (Application *)malloc(sizeof(Application));
78.   app->shapes_length = 0;
79.   app->shapes = (Shape **)calloc(app->shapes_length, sizeof(Shape));
80.   app->add_to_shapes = &app_add_to_shapes;
81.   app->add_shape = &app_add_shape;
82.   app->get_shape = &app_get_shape;
83.   app->get_shapes = &app_get_shapes;
84.   app->get_shape_clone = &app_get_shape_clone;
85.   app->print_shapes = &app_print_shapes;
86.   return app;
87. }

复制代码

测试调用

1. #include "../src/func.h"
3. int main(void)
4. {
5.   printf("test start:\r\n");
6.   /**
7.    * 原型模式主要就是复制已有的对象，而无需实例化类，从而提升实例化对象时的性能
8.    * 其实就是复制实例的属性到新对象上，减少了执行构造的步骤。
9.    */
10.   Application *application = application_constructor();
11.   application->add_to_shapes(application);
12.   Shape *shape_clone = application->get_shape_clone(application, 0);
13.   // SetColor需要接口中定义
14.   shape_clone->set_color(shape_clone, "gray");
15.   printf("\r\n shape_clone : %s", shape_clone->to_string(shape_clone));
16.   // 直接更改
17.   // application->get_shape(application, 3)->set_color(application->get_shape(application, 3), "yellow");
18.   application->print_shapes(application);
20.   /*********************** 分割线 ******************************************/
21.   // 追加一个Squre实例，相关属性为空
22.   application->add_shape(application, (Shape *)square_constructor("square"));
23.   // 打不打印查看结果
25.   for (int i = 0; i < application->shapes_length; i++)
26.   {
27.     Shape *shape = application->shapes[i];
28.     shape->draw(shape);
29.     printf("\r\n shape_%d %s", i, shape->to_string(shape));
30.   }
31. }

复制代码

更多语言版本

不同语言实现设计模式：https://github.com/microwind/design-pattern

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！