上一篇《访问者模式》 下一篇《享元模式》
简介：
原型模式，它是一种创建型设计模式，它允许通过复制原型对象来创建新的对象，而无需知道创建的细节。其工作原理是将一个原型对象传递给要创建的对象，然后通过请求原型对象复制自己来实施创建。
在原型模式中，克隆方法所创建的对象是全新对象，它们在内存中拥有全新的地址，通常对克隆所产生的对象进行修改不会对原型对象造成任何影响，每个克隆对象都是相互独立的。通过不同的方式对克隆对象进行修改后，可以得到一系列相似但不完全相同的对象。
需要注意的是，对原型对象的浅拷贝，对于数据类型是基本数据类型的成员变量，会直接进行值传递，也就是将该属性值复制一份给新的对象；对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。在这种情况下,在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
原型模式的使用场景：
1、类初始化需要消化非常多的资源，包括数据、硬件资源等。通过原型拷贝可以避免这些消耗。
2、通过使用new关键字创建一个对象需要非常繁琐的数据准备或访问权限。
3、一个对象需要提供给其他对象访问，而且各个调用者可能需要修改其值。在这种情况下，可以考虑使用原型模式拷贝多个对象供调用者使用，即保护性拷贝。
在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。
原型模式的创建步骤：
1、定义抽象原型类：抽象原型类是定义具有克隆自己的方法的接口，是所有具体原型类的公共父类。
2、定义具体原型类：具体原型类实现抽象原型类中的克隆方法，返回自己的一个克隆对象。
3、定义客户类：客户类让一个原型克隆自身，从而创建一个新的对象。在客户类中只需要直接实例化或通过工厂方法等创建一个对象，再通过调用该对象的克隆方法复制得到多个相同的对象。
原型模式通过复制原型对象来创建新对象，减少了创建新对象时所消耗的时间和资源。同时，由于复制的是原型对象，因此不会影响原对象的状态。
原型模式的优点，主要包括：
1、简化创建过程：原型模式可以简化对象的创建过程，通过复制一个已有实例可以提高新实例的创建效率。
2、扩展性较好：由于在原型模式中提供了抽象原型类，在客户端可以针对抽象原型类进行编程，而将具体原型类写在配置文件中，增加或减少产品类对原有系统都没有任何影响。
3、提供简化的创建结构：原型模式中产品的复制是通过封装在原型类中的克隆方法实现的，无须专门的工厂类来创建产品。
4、支持深拷贝：原型模式可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份，并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用（如恢复到某一历史状态），可辅助实现撤销操作。
总的来说，原型模式可以大大提高创建对象的效率，同时还能保证系统的扩展性和灵活性。
原型模式的缺点，主要包括：
1、在实现深拷贝时可能需要比较复杂的代码，需要为每一个类配备一个克隆方法，而且该克隆方法需要对类的功能进行通盘考虑，这对全新的类来说不是很难，但对已有的类进行改造时，不一定是件容易的事，必须修改其源代码，违背了“开闭原则”。
示例：
一、C#原型模式
以下是一个示例，展示了如何在C#中实现原型模式：
using System;
namespace PrototypePatternExample
{
// 抽象原型类
public abstract class Prototype
{
public abstract Prototype Clone();
}
// 具体原型类
public class ConcretePrototype : Prototype
{
private string _property;
public ConcretePrototype(string property)
{
_property = property;
}
public override Prototype Clone()
{
// 使用深拷贝复制对象
ConcretePrototype clone = (ConcretePrototype)MemberwiseClone(this);
return clone;
}
public void Display()
{
Console.WriteLine("Property: " + _property);
}
}
class Program
{
static void Main(string[] args)
{
// 创建原型对象
ConcretePrototype prototype = new ConcretePrototype("Hello World");
// 克隆原型对象
ConcretePrototype clonePrototype = (ConcretePrototype)prototype.Clone();
// 显示原型对象和克隆对象的属性值是否相同
prototype.Display();
clonePrototype.Display();
Console.ReadLine();
}
}
}二、java原型模式
原型模式通常通过以下方式实现：
import java.util.ArrayList;
import java.util.List;
abstract class Shape {
private String name;
public Shape(String name) {
this.name = name;
}
public String getName() {
return name;
}
public abstract void draw();
// 实现克隆方法
public Shape clone() {
try {
return (Shape) this.getClass().newInstance();
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}
class Circle extends Shape {
private int radius;
public Circle(String name, int radius) {
super(name);
this.radius = radius;
}
@Override
public void draw() {
System.out.println("Drawing Circle");
}
}
class Rectangle extends Shape {
private int width;
private int height;
public Rectangle(String name, int width, int height) {
super(name);
this.width = width;
this.height = height;
}
@Override
public void draw() {
System.out.println("Drawing Rectangle");
}
}
public class PrototypePatternDemo {
public static void main(String[] args) {
List<Shape> shapeList = new ArrayList<>();
shapeList.add(new Circle("Circle 1", 5));
shapeList.add(new Rectangle("Rectangle 1", 5, 10));
shapeList.add(new Circle("Circle 2", 10));
shapeList.add(new Rectangle("Rectangle 2", 10, 20));
// 使用原型模式创建对象，节省创建对象的时间
for (Shape shape : shapeList) {
Shape cloneShape = shape.clone();
System.out.println("Original Shape: " + shape.getName());
System.out.println("Clone Shape: " + cloneShape.getName());
}
}
} 三、javascript原型模式
在JavaScript中，实现原型模式的关键是使用构造函数和原型对象。
下面是一个简单的JavaScript原型模式示例：
// 定义原型对象
var CarProto = {
color: "blue",
speed: 0,
start: function() {
console.log("Car started");
},
stop: function() {
console.log("Car stopped");
}
};
// 定义构造函数
function Car(color) {
this.color = color;
this.speed = 0;
// 将构造函数prototype属性指向原型对象
this.prototype = CarProto;
}
// 定义子类
function SportCar() {
// 调用父类构造函数
Car.call(this, "red");
// 重写父类方法
this.start = function() {
console.log("SportCar started");
};
}
// 设置原型对象，让SportCar继承CarProto
SportCar.prototype = CarProto;在这个示例中，我们定义了一个CarProto原型对象，它包含了汽车的属性和方法。然后我们定义了一个Car构造函数，它接受颜色参数，并设置速度属性为0，并将它的prototype属性指向CarProto。这样，当我们创建一个新的汽车对象时，它就会继承CarProto的属性和方法。
然后我们定义了一个SportCar子类，它调用父类构造函数，并重写了父类的start方法。最后我们将SportCar.prototype设置为CarProto，这样SportCar就可以继承CarProto的属性和方法了。现在我们可以使用new关键字来创建SportCar对象了。
四、C++原型模式
以下是在C++中实现原型模式：
#include <iostream>
#include <string>
#include <map>
using namespace std;
// 定义原型接口
class Prototype {
public:
virtual Prototype* clone() = 0;
virtual void display() = 0;
};
// 具体原型类
class ConcretePrototype : public Prototype {
private:
string name;
public:
ConcretePrototype(string n) : name(n) {}
void setName(string n) { name = n; }
string getName() { return name; }
// 实现克隆方法
Prototype* clone() { return new ConcretePrototype(*this); }
// 实现显示方法
void display() { cout << "ConcretePrototype " << name << endl; }
};
// 工厂类
class PrototypeFactory {
private:
map<string, Prototype*> prototypes; // 存储原型对象的映射表
public:
PrototypeFactory() {}
Prototype* create(string type) { // 创建原型对象
if (prototypes.find(type) == prototypes.end()) { // 如果该类型的原型对象不存在，则创建并存储在映射表中
prototypes[type] = new ConcretePrototype(type);
}
return prototypes[type]->clone(); // 返回克隆后的对象
}
};
int main() {
PrototypeFactory factory;
Prototype* p1 = factory.create("prototype1"); // 创建原型对象1的克隆对象1
p1->display(); // 显示原型对象1的名称，输出 "ConcretePrototype prototype1"
Prototype* p2 = factory.create("prototype1"); // 创建原型对象1的克隆对象2
p2->setName("prototype2"); // 设置克隆对象2的名称，不影响原型对象1的名称
p2->display(); // 显示原型对象1的名称，输出 "ConcretePrototype prototype1"，因为克隆对象2的名称没有修改成功，仍然是原型对象1的名称
delete p1; // 释放内存空间，因为p1和p2都是通过克隆得到的，所以应该释放内存空间，避免内存泄漏问题。
delete p2; // 释放内存空间，因为p1和p2都是通过克隆得到的，所以应该释放内存空间，避免内存泄漏问题。
return 0;
}五、python原型模式
以下是在python中实现原型模式：
import copy
# 定义原型类
class Prototype:
def __init__(self, name):
self.name = name
def clone(self):
return copy.deepcopy(self)
# 定义具体原型类
class ConcretePrototype(Prototype):
def __init__(self, name):
super().__init__(name)
self.data = []
def add_data(self, data):
self.data.append(data)
def clone(self):
return ConcretePrototype(self.name)
# 测试代码
if __name__ == '__main__':
# 创建原型对象
prototype1 = ConcretePrototype("prototype1")
prototype1.add_data(1)
prototype1.add_data(2)
print("Prototype 1 data:", prototype1.data)
# 克隆原型对象
clone1 = prototype1.clone()
clone1.add_data(3)
print("Clone 1 data:", clone1.data) # [1, 2, 3]
print("Prototype 1 data:", prototype1.data) # [1, 2]
# 克隆克隆对象，避免修改原对象的影响
clone2 = clone1.clone()
clone2.add_data(4)
print("Clone 2 data:", clone2.data) # [1, 2, 4]
print("Prototype 1 data:", prototype1.data) # [1, 2]六、go原型模式
以下是一个示例，展示了如何在go中实现原型模式：
package main
import (
"fmt"
)
// 原型接口
type Prototype interface {
Clone() Prototype
}
// 具体原型类
type ConcretePrototype struct {
Name string
}
// 克隆方法实现原型接口
func (p *ConcretePrototype) Clone() Prototype {
return &ConcretePrototype{Name: p.Name}
}
func main() {
// 创建原型对象
prototype1 := &ConcretePrototype{Name: "Prototype1"}
// 克隆原型对象
clone1 := prototype1.Clone()
fmt.Println("Clone 1 Name:", clone1.(*ConcretePrototype).Name) // 输出：Clone 1 Name: Prototype1
// 修改原型对象
prototype1.Name = "Prototype2"
fmt.Println("Prototype 1 Name:", prototype1.(*ConcretePrototype).Name) // 输出：Prototype 1 Name: Prototype2
// 克隆克隆对象，避免修改原对象的影响
clone2 := clone1.Clone()
fmt.Println("Clone 2 Name:", clone2.(*ConcretePrototype).Name) // 输出：Clone 2 Name: Prototype1
}七、PHP原型模式
以下是一个示例，展示了如何在PHP中实现原型模式：
<?php
class Prototype implements Cloneable {
private $name;
public function __construct($name) {
$this->name = $name;
}
public function getName() {
return $this->name;
}
public function setName($name) {
$this->name = $name;
}
public function clone() {
return clone $this;
}
}
// 创建原型对象
$prototype = new Prototype("Original");
echo "Prototype Name: " . $prototype->getName() . "\n";
// 克隆原型对象
$clone = $prototype->clone();
echo "Clone Name: " . $clone->getName() . "\n";
// 修改原型对象的属性
$prototype->setName("Modified");
echo "Prototype Name after modification: " . $prototype->getName() . "\n";
// 克隆克隆对象，避免修改原对象的影响
$clone2 = $clone->clone();
echo "Clone 2 Name: " . $clone2->getName() . "\n";
《完结》
上一篇《访问者模式》 下一篇《享元模式》
