设计师看什么网站,cc彩球网站总代理怎么做,知名的定制网站建设提供商,win7一键优化工具上一篇《访问者模式》 下一篇《享元模式》
简介#xff1a;
原型模式#xff0c;它是一种创建型设计模式#xff0c;它允许通过复制原型对象来创建新的对象#xff0c;而无需知道创建的细节。其工作原…上一篇《访问者模式》 下一篇《享元模式》
简介
原型模式它是一种创建型设计模式它允许通过复制原型对象来创建新的对象而无需知道创建的细节。其工作原理是将一个原型对象传递给要创建的对象然后通过请求原型对象复制自己来实施创建。
在原型模式中克隆方法所创建的对象是全新对象它们在内存中拥有全新的地址通常对克隆所产生的对象进行修改不会对原型对象造成任何影响每个克隆对象都是相互独立的。通过不同的方式对克隆对象进行修改后可以得到一系列相似但不完全相同的对象。
需要注意的是对原型对象的浅拷贝对于数据类型是基本数据类型的成员变量会直接进行值传递也就是将该属性值复制一份给新的对象对于数据类型是引用数据类型的成员变量比如说成员变量是某个数组、某个类的对象等那么浅拷贝会进行引用传递也就是只是将该成员变量的引用值内存地址复制一份给新的对象。在这种情况下,在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
原型模式的使用场景 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) { ListShape 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: mapstring, 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; 《完结》
上一篇《访问者模式》 下一篇《享元模式》
