设计模式——5. 原型模式

已于 2023-10-08 23:03:31 修改
阅读量375 收藏
点赞数
分类专栏： 设计模式大全 文章标签： 设计模式 原型模式 python golang c++ javascript java
于 2023-09-26 22:33:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guohuang/article/details/133325180
版权

1. 说明

原型模式（Prototype Pattern）是一种创建型设计模式，其核心思想是通过复制（克隆）一个现有对象来创建新的对象，而不是通过实例化类来创建。这意味着在原型模式中，新对象的创建不需要知道具体的类，而是通过复制现有对象的属性和状态来创建。原型模式通常包括一个原型接口或抽象类，以及具体的原型类实现该接口或继承该抽象类。

关键特点和概念：

  1. 原型接口或抽象类（Prototype）：定义了复制自身的方法，通常包括一个 clone 方法。
  2. 具体原型类（ConcretePrototype）：实现了原型接口或继承了原型抽象类，并提供了具体的克隆方法。这个类的对象可以被复制以创建新的对象。
  3. 客户端（Client）：通过请求原型对象来复制新对象的客户端代码。

原型模式有一些注意事项：

  • 需要确保被克隆的对象是可复制的，即对象的类必须实现克隆方法或接口。
  • 克隆对象可能需要处理对象的内部状态，以确保对象的复制是正确的。

总之，原型模式是一种有用的设计模式，适用于需要创建对象副本的情况，它通过克隆现有对象来实现创建，提高了效率并降低了复杂性。

2. 使用的场景

以下是原型模式使用的场景：

  1. 创建成本高昂的对象： 当创建对象的成本较高，例如需要进行大量的计算、数据库查询、网络请求或其他耗时操作时，使用原型模式可以通过复制现有对象来提高性能，而不必重新计算或重新获取数据。
  2. 复杂对象的创建： 当对象的构造过程非常复杂，包括多个步骤和设置多个属性时，原型模式可以让您避免编写冗长的构造函数，只需复制现有对象并稍微调整属性即可。
  3. 对象初始化复杂： 当对象需要进行复杂的初始化工作，例如读取配置文件、连接数据库或进行身份验证等操作时，原型模式可以复制一个已初始化的对象，而不必重新执行初始化逻辑。
  4. 对象的多个变体： 如果需要创建对象的多个变体或配置，而这些变体仅有少量属性不同，原型模式可以通过复制一个原型对象并修改其差异属性来创建这些变体。
  5. 对象的深拷贝： 原型模式可以实现对象的深拷贝，即复制对象及其关联对象的所有内容，而不仅仅是浅拷贝。这对于复杂的数据结构非常有用。
  6. 动态配置对象： 在某些情况下，系统需要根据用户输入或其他条件来配置对象。原型模式允许您创建一个基本配置的原型对象，然后根据需要进行修改。
  7. 对象池： 一些应用程序需要维护一个对象池，以便在需要时获取可重用的对象。原型模式可以用来创建池中的对象。

总之，原型模式在需要创建对象副本、降低创建成本、提高性能或简化对象创建过程的情况下非常有用。它通过复制现有对象来创建新对象，提供了一种灵活的方式来处理对象的创建和初始化。

3. 应用例子

以下是一个使用Python语言实现原型模式的示例，假设我们有一个图形编辑器，需要创建不同类型的图形对象（如圆形和矩形），并且可以复制已有的图形对象来创建新的图形对象:

import copy

# 创建原型基类
class ShapePrototype:
    def clone(self):
        return copy.copy(self)

# 创建具体的图形类：圆形
class Circle(ShapePrototype):
    def __init__(self, radius):
        self.radius = radius

    def __str__(self):
        return f"Circle with radius {self.radius}"

# 创建具体的图形类：矩形
class Rectangle(ShapePrototype):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def __str__(self):
        return f"Rectangle with width {self.width} and height {self.height}"

# 客户端代码
if __name__ == "__main__":
    # 创建原型对象
    circle_prototype = Circle(5)
    rectangle_prototype = Rectangle(10, 20)

    # 复制原型对象来创建新对象
    circle1 = circle_prototype.clone()
    circle2 = circle_prototype.clone()
    rectangle1 = rectangle_prototype.clone()

    # 修改复制后的对象的属性
    circle1.radius = 8
    circle2.radius = 10
    rectangle1.width = 15
    rectangle1.height = 25

    # 打印对象
    print(circle1)       # 输出: Circle with radius 8
    print(circle2)       # 输出: Circle with radius 10
    print(rectangle1)    # 输出: Rectangle with width 15 and height 25

在这个示例中：

  • ShapePrototype 是原型基类，它包含一个 clone 方法，该方法使用 copy.copy 来复制对象。
  • Circle 和 Rectangle 是具体的图形类，它们继承自 ShapePrototype 并实现了 str 方法以便于打印对象的信息。
  • 客户端代码中，我们创建了两个原型对象 circle_prototype 和 rectangle_prototype，然后使用 clone 方法复制这些原型对象来创建新的图形对象。通过修改复制后的对象的属性，我们可以创建具有不同属性的图形对象。

这个示例展示了如何使用原型模式创建对象的副本，而不必关心对象创建的细节，从而实现了对象的复用和灵活性。

4. 实现要素

原型模式的实现要素包括以下部分：

  1. 原型接口或抽象类（Prototype）： 定义了复制自身的方法，通常包括一个 clone 方法，该方法用于创建对象的副本。
  2. 具体原型类（Concrete Prototype）： 实现了原型接口或继承了原型抽象类，它包含了复制对象的逻辑，并且允许创建对象的副本。
  3. 客户端（Client）： 负责创建和使用原型对象，通常通过原型对象的 clone 方法来创建新的对象副本。

5. UML图

以下是原型模式的简化 UML 类图：

+------------------+
|   Prototype     |
+------------------+
|  +clone(): Prototype   |
+------------------+
        ^
        |
        |
        |
+------------------+
|  ConcretePrototype |
+------------------+
|  +clone(): ConcretePrototype |
+------------------+
        ^
        |
        |
        |
+------------------+
|      Client      |
+------------------+
|                  |
|  +createPrototype(): Prototype |
|                  |
+------------------+

在 UML 类图中：

  • Prototype 是原型接口或抽象类，定义了 clone 方法。
  • ConcretePrototype 是具体原型类，实现了 Prototype 接口，包含了复制对象的逻辑。
  • Client 是客户端类，它通过调用 createPrototype 方法来创建新的对象副本，而不需要直接与具体原型类交互。

这个 UML 类图反映了原型模式的关键要素和类之间的关系，帮助理解原型模式的结构和工作原理。客户端通过调用原型对象的 clone 方法来复制对象，从而实现对象的创建和复制。

6. Java/golang/javascrip/C++ 等语言实现方式

6.1 Java实现

上述例子用Java语言实现示例如下：

import java.util.HashMap;
import java.util.Map;

// 创建原型接口
interface ShapePrototype {
    ShapePrototype clone();
    String getInfo();
}

// 创建具体的图形类：圆形
class Circle implements ShapePrototype {
    private String type;

    public Circle(String type) {
        this.type = type;
    }

    @Override
    public ShapePrototype clone() {
        return new Circle(this.type);
    }

    @Override
    public String getInfo() {
        return "Circle of type " + type;
    }
}

// 创建具体的图形类：矩形
class Rectangle implements ShapePrototype {
    private String type;

    public Rectangle(String type) {
        this.type = type;
    }

    @Override
    public ShapePrototype clone() {
        return new Rectangle(this.type);
    }

    @Override
    public String getInfo() {
        return "Rectangle of type " + type;
    }
}

// 创建原型管理器
class ShapePrototypeManager {
    private Map<String, ShapePrototype> shapeMap = new HashMap<>();

    public void addShape(String key, ShapePrototype shapePrototype) {
        shapeMap.put(key, shapePrototype);
    }

    public ShapePrototype getShape(String key) {
        ShapePrototype shapePrototype = shapeMap.get(key);
        if (shapePrototype != null) {
            return shapePrototype.clone();
        }
        return null;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建原型管理器
        ShapePrototypeManager manager = new ShapePrototypeManager();

        // 添加具体图形原型
        manager.addShape("circle", new Circle("solid"));
        manager.addShape("rectangle", new Rectangle("dotted"));

        // 使用原型创建新对象
        ShapePrototype clonedCircle = manager.getShape("circle");
        ShapePrototype clonedRectangle = manager.getShape("rectangle");

        // 打印对象信息
        System.out.println(clonedCircle.getInfo());    // 输出: Circle of type solid
        System.out.println(clonedRectangle.getInfo()); // 输出: Rectangle of type dotted
    }
}

6.2 Golang实现

上述例子用golang实现示例如下：

package main

import (
        "fmt"
        "sync"
)

// 创建原型接口
type ShapePrototype interface {
        Clone() ShapePrototype
        GetInfo() string
}

// 创建具体的图形类：圆形
type Circle struct {
        Type string
}

func (c *Circle) Clone() ShapePrototype {
        return &Circle{Type: c.Type}
}

func (c *Circle) GetInfo() string {
        return fmt.Sprintf("Circle of type %s", c.Type)
}

// 创建具体的图形类：矩形
type Rectangle struct {
        Type string
}

func (r *Rectangle) Clone() ShapePrototype {
        return &Rectangle{Type: r.Type}
}

func (r *Rectangle) GetInfo() string {
        return fmt.Sprintf("Rectangle of type %s", r.Type)
}

// 创建原型管理器
type ShapePrototypeManager struct {
        prototypes map[string]ShapePrototype
        mu         sync.Mutex
}

func NewShapePrototypeManager() *ShapePrototypeManager {
        return &ShapePrototypeManager{
                prototypes: make(map[string]ShapePrototype),
        }
}

func (m *ShapePrototypeManager) AddShape(key string, prototype ShapePrototype) {
        m.mu.Lock()
        defer m.mu.Unlock()
        m.prototypes[key] = prototype
}

func (m *ShapePrototypeManager) GetShape(key string) ShapePrototype {
        m.mu.Lock()
        defer m.mu.Unlock()
        prototype, ok := m.prototypes[key]
        if !ok {
                return nil
        }
        return prototype.Clone()
}

// 客户端代码
func main() {
        // 创建原型管理器
        manager := NewShapePrototypeManager()

        // 添加具体图形原型
        manager.AddShape("circle", &Circle{Type: "solid"})
        manager.AddShape("rectangle", &Rectangle{Type: "dotted"})

        // 使用原型创建新对象
        clonedCircle := manager.GetShape("circle")
        clonedRectangle := manager.GetShape("rectangle")

        // 打印对象信息
        fmt.Println(clonedCircle.GetInfo())    // 输出: Circle of type solid
        fmt.Println(clonedRectangle.GetInfo()) // 输出: Rectangle of type dotted
}

6.3 Javascript实现

上述例子用javascript实现示例如下：

// 创建原型接口
class ShapePrototype {
    clone() {}
    getInfo() {}
}

// 创建具体的图形类：圆形
class Circle extends ShapePrototype {
    constructor(type) {
        super();
        this.type = type;
    }

    clone() {
        return new Circle(this.type);
    }

    getInfo() {
        return `Circle of type ${this.type}`;
    }
}

// 创建具体的图形类：矩形
class Rectangle extends ShapePrototype {
    constructor(type) {
        super();
        this.type = type;
    }

    clone() {
        return new Rectangle(this.type);
    }

    getInfo() {
        return `Rectangle of type ${this.type}`;
    }
}

// 创建原型管理器
class ShapePrototypeManager {
    constructor() {
        this.prototypes = {};
    }

    addShape(key, prototype) {
        this.prototypes[key] = prototype;
    }

    getShape(key) {
        const prototype = this.prototypes[key];
        if (prototype) {
            return prototype.clone();
        }
        return null;
    }
}

// 客户端代码
const manager = new ShapePrototypeManager();

// 添加具体图形原型
manager.addShape("circle", new Circle("solid"));
manager.addShape("rectangle", new Rectangle("dotted"));

// 使用原型创建新对象
const clonedCircle = manager.getShape("circle");
const clonedRectangle = manager.getShape("rectangle");

// 打印对象信息
console.log(clonedCircle.getInfo());    // 输出: Circle of type solid
console.log(clonedRectangle.getInfo()); // 输出: Rectangle of type dotted

6.4 C++实现

上述例子用C++实现如下：

#include <iostream>
#include <unordered_map>

// 创建原型接口
class ShapePrototype {
public:
    virtual ShapePrototype* clone() const = 0;
    virtual std::string getInfo() const = 0;
};

// 创建具体的图形类：圆形
class Circle : public ShapePrototype {
private:
    std::string type;

public:
    Circle(const std::string& type) : type(type) {}

    ShapePrototype* clone() const override {
        return new Circle(*this);
    }

    std::string getInfo() const override {
        return "Circle of type " + type;
    }
};

// 创建具体的图形类：矩形
class Rectangle : public ShapePrototype {
private:
    std::string type;

public:
    Rectangle(const std::string& type) : type(type) {}

    ShapePrototype* clone() const override {
        return new Rectangle(*this);
    }

    std::string getInfo() const override {
        return "Rectangle of type " + type;
    }
};

// 创建原型管理器
class ShapePrototypeManager {
private:
    std::unordered_map<std::string, ShapePrototype*> prototypes;

public:
    void addShape(const std::string& key, ShapePrototype* prototype) {
        prototypes[key] = prototype;
    }

    ShapePrototype* getShape(const std::string& key) const {
        auto it = prototypes.find(key);
        if (it != prototypes.end()) {
            return it->second->clone();
        }
        return nullptr;
    }
};

// 客户端代码
int main() {
    // 创建原型管理器
    ShapePrototypeManager manager;

    // 添加具体图形原型
    manager.addShape("circle", new Circle("solid"));
    manager.addShape("rectangle", new Rectangle("dotted"));

    // 使用原型创建新对象
    ShapePrototype* clonedCircle = manager.getShape("circle");
    ShapePrototype* clonedRectangle = manager.getShape("rectangle");

    // 打印对象信息
    if (clonedCircle) {
        std::cout << clonedCircle->getInfo() << std::endl;    // 输出: Circle of type solid
    }
    if (clonedRectangle) {
        std::cout << clonedRectangle->getInfo() << std::endl; // 输出: Rectangle of type dotted
    }

    // 释放内存
    delete clonedCircle;
    delete clonedRectangle;

    return 0;
}

7. 练习题

设计一个电子设备控制器，其中有多种不同类型的遥控器按钮。每个按钮可以控制一种特定类型的设备，例如电视、音响、灯等。当用户按下按钮时，设备应该启动并执行相应的操作。使用原型模式设计一个控制器，以便用户可以自定义按钮的功能，并创建多个相似的按钮，每个按钮都可以独立控制一个设备。

要求：

  1. 创建一个抽象设备控制器原型类（DeviceControllerPrototype），其中包含 clone 方法和执行操作的抽象方法。
  2. 创建具体的设备控制器类（如TVController、AudioController、LightController），它们继承自抽象设备控制器原型类，实现具体的操作方法。
  3. 创建一个设备控制器管理器类，用于存储和获取不同类型的设备控制器原型对象。
  4. 客户端代码应该能够从设备控制器管理器中获取不同类型的设备控制器，并根据用户的需求创建按钮并执行相应的操作。

你可以在评论区里或者私信我回复您的答案，这样我或者大家都能帮你解答，期待着你的回复~

guohuang
关注
专栏目录
Java设计模式——原型模式
流楚丶格念的博客
10-30 1194
关键代码： 1、实现克隆操作，在 JAVA 实现 Cloneable 接口，重写 clone()，在 .NET 中可以使用 Object 类的 MemberwiseClone() 方法来实现对象的浅拷贝或通过序列化的方式来实现深拷贝。1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。设计模式，允许一个对象在创建另外一个可定制的对象，无需知道如何创建的细节。5、一个对象多个修改者的场景。
设计模式——JAVA.docx
04-03
- **创建型模式**（共5种）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 - **结构型模式**（共7种）：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 - **行为型...
C++设计模式——Prototype Pattern原型模式
CoderZZ_2024的博客
09-12 1799
原型模式是一种创建型设计模式，它允许通过克隆已有对象来创建新对象，从而无需调用显式的实例化过程。原型模式的设计，使得它可以创建一个与原型对象相同或类似的新对象，同时又可以减少对象实例化操作产生的性能开销，使得创建对象的操作更加便捷，它减少了大量不必要的重复工作，并提高了系统性能。当创建对象的操作比较复杂和耗时的时候，原型模式则提供了一个更加高效和简单的创建对象的模式，它可以更加快速的创建对象的副本，且不需要依赖对象的某些实例化步骤，它避免了使用传统的new关键字创建对象实例时的复杂构造过程。
Java 设计模式——原型模式
代码星辰的博客
07-22 1359
本文介绍了原型模式的相关知识。
Scala设计模式Part I. 创建模式——4.原型模式
肖飞figo的云计算专栏
05-27 782
描述 用原型实例指定要创建的对象类型，并通过原型拷贝创建新对象。 原型提供了另一种不同于工厂方法的方式对创建者类与产品类进行解耦。工厂方法是由子类集成工厂类并重载工厂方法返回具体的类，而原型模式则是用组合代替继承。创建者通过一个提供克隆方法创建对象实例的原型对象进行参数化。通过继承原型对象（如下图中的Concrete Prototype1）或者参数化的方式创建不同的对象。参数化能帮助减少系统中类
Python设计模式——原型模式
钟灵毓秀的博客
10-12 896
设计模式之原型模式，python代码实现与总结
C++ 设计模式——原型模式
qq_68194402的博客
08-18 1039
原型模式通过定义 **Prototype** 和 **ConcretePrototype** 的关系，使得对象的克隆过程更加灵活和高效。客户端只需依赖于 **Prototype** 接口，能够动态创建新的对象实例，增强了系统的可扩展性和可维护性。
设计模式——原型模式
Florenza的博客
02-21 1260
原型模式是一种创建型设计模式，它允许一个对象创建另一个可定制的对象，而无需了解如何创建这个对象的细节。这种模式的核心在于对象拷贝，即通过将一个原型对象传给要创建的对象，然后由这个要创建的对象通过请求原型对象拷贝自身来实施创建。小麻雀icknn/设计模式练习 - Gitee.comJava中Object类是所有类的根类，Object 类提供了一个clone(）方法，该方法可以将一一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个接口Cloneable。
JavaScript设计模式——原型模式
前端御书房
10-06 436
JavaScript设计模式，原型模式——持续更新中
23种设计模式——原型模式
万里顾一程的博客
11-14 2537
文章目录23种设计模式——原型模式1、原型模式概述2、原型模式的结构图3、原型模式的实现3.1、浅拷贝和深拷贝3.2、实现浅拷贝3.2、实现深拷贝 23种设计模式——原型模式 1、原型模式概述 原型模式介绍 1、原型模式(Prototype模式)是指：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。 2、原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节，因此用这种方式创建对象非常高效
创建型设计模式——原型模式
★★光亭★★
02-11 5737
创建型设计模式——原型模式
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
本资料“《java设计模式》课后习题模拟试题解答——刘伟.zip”主要涵盖了Java设计模式的学习与应用，特别是针对刘伟教授的相关课程的课后习题及模拟试题的解答。 设计模式分为三大类：创建型、结构型和行为型模式。...
SSM模式学习路线-----[Spring入门笔记]（csdn）————程序.pdf
12-04
- **Aop设计的初衷**：将分散在各个类中的共同行为（如日志记录、事务管理）提取出来，形成独立的模块，便于维护和扩展。 6. **AOP的实现方式** - **基于XML的声明式AspectJ**：在XML配置文件中定义切面和通知。 ...
设计模式、系统设计 record part02
m0_47505062的博客
09-27 1189
软件设计模式1.应对重复发生的问题2.解决方案3.可以反复使用1.本质是面向对象2.优点很多1.创建型-创建和使用分离2.结构型-组合3.行为型-协作5+7+11=23种模式UML-统一建模语言-Unified Modeling Language1.可视化图形化2.各种图（9种图）3.可以同时表示静态信息、动态信息类图就是图形化显式类关联关系。
单例设计模式
SunnyRivers
09-26 908
单例模式（Singleton Pattern）指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点，属于创建型设计模式。单例模式在现实生活中的应用非常广泛，例如公司CEO、部门经理等都属于单例模型。J2EE标准中的ServletContext和ServletContextConfig、Spring框架应用中的ApplicationContext、数据库中的连接池等也都是单例模式。对于Java来说，单例模式可以保证在一个JVM中只存在单一实例。单例模式的应用场景主要有以下几个方面。
Qt C++设计模式-＞享元模式
m0_46494667的博客
09-24 1382
享元模式（Flyweight Pattern）是一种结构型设计模式，旨在通过共享相同对象来减少内存使用，尤其适合在大量重复对象的情况下。它通过将对象的可共享部分抽取出来，并在多个上下文中共享，从而避免对象的多次创建。
行为设计模式 -模板方法模式- JAVA
最新发布
智的博客
09-28 1646
模板方法是一种行为设计模式。模板方法设计模式用于创建方法存根并将某些实现步骤推迟到子类。模板方法模式定义了一个算法的步骤，并允许子类别为一个或多个步骤提供其实践方式。让子类别在不改变算法架构**的情况下，重新定义算法中的某些步骤。在面向对象程序设计过程中，我们常常会遇到这种情况：设计一个系统时知道了算法所需的关键步骤，而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。通俗理解，就是设计构建一个对象的时候，类的步骤已经固定了，可是某些类的实现逻辑。
【Java】六大设计原则和23种设计模式
weixin_71491685的博客
09-28 1237
代理模式给某一个对象提供一个代理对象并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。举个例子来说明：假如说我现在想买一辆二手车，虽然我可以自己去找车源，做质量检测等一系列的车辆过户流程，但是这确实太浪费我得时间和精力了。我只是想买一辆车而已为什么我还要额外做这么多事呢？于是我就通过中介公司来买车，他们来给我找车源，帮我办理车辆过户流程，我只是负责选择自己喜欢的车，然后付钱就可以了。
C#设计模式——原型模式(Prototype Pattern)
06-01
原型模式是一种创建型设计模式，它允许通过复制已有对象来创建新对象，而不是通过实例化类并设置其属性来创建新对象。这样可以避免重复创建相同的对象，从而提高了创建对象的效率。 在原型模式中，原型对象是被复制...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

guohuang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值