定义
原型模式：原型模式用于创建重复的对象，实现对象的拷贝。这种模式类似于创建型模式，提供了创建对象的最佳模式。
这种模式存在的应用场景在于，能够复制当前对象，实现对象数据的克隆。比如：如果一个对象的数据需要经过较高代价的数据库操作，采用原型模式能够较好的缓存当前对象，减少数据库的访问量。
使用场景
思想：用实例对象，指导对象的创建工作.
应用：一个复杂的对象，包含多种数据和结构，层次较深时，适用与原型模式（当需要创建一个与复杂对象部分数据相同的对象），如果重新创建，过程较为复杂，费时费力，采取原型模式可以快速构建一个类似的对象。
实例场景：1.一个楼盘有名称，地址和施工队三个成员变量。施工队有名称，人数和包工头。包工头有名称和年龄。现在要建设一个隔壁的楼盘，还是由这个施工队进行建设的，只是地址不同。
2.系统中已经有一架飞机，飞机有名称和型号和厂商。厂商有名称，地址和负责人。负责人有姓名和年龄。现在要一家相同的飞机由不同的负责人进行指导生产的，如何快速创建这样的对象。
下面是一张UML图用来说明原型模式的关系
image
下面是一个具体的应用场景：
如何实现不同型号的手机由相同的工厂生产的问题，快速创建这样的一个对象
image
结构：手机由名称,价格，生产工厂组成。生产工厂由工程师和名称组成。工程师由姓名这个基本属性。
现在为了快速复制同一工厂的不同手机，解决这一实际应用场景。
Phone类
public class Phone {
public String name; //手机名称
public float price; //价钱
public Factory factory; //工厂
@Override
public String toString() {
return "手机名称:"+this.name+" 价钱:"+this.price+this.factory.toString();
}
public Phone Clone(){
Phone phone =null;
try{
phone=new Phone();
if(this.name!=null){
phone.name=this.name;
}
if(this.price!=0){
phone.price=this.price;
}
if(this.factory!=null){
phone.factory=this.factory.Clone();
}
}catch (Exception e){
new RuntimeException(e);
}
return phone;
}
}
Factory类
public class Factory implements Cloneable{
public String name; //工厂名称
public Person Manager; //负责人
@Override
public String toString() {
return " 工厂名称:"+this.name+" 负责人:"+Manager.toString();
}
public Factory Clone(){
Factory factory =null;
try{
factory=new Factory();
if(this.name!=null){
factory.name=this.name;
}
if(this.Manager!=null){
factory.Manager=this.Manager.Clone();
}
}catch (Exception e){
new RuntimeException(e);
}
return factory;
}
}
Person类
public class Person implements Cloneable{
public String name; //名称
@Override
public String toString() {
return this.name;
}
public Person Clone(){
Person person =null;
try{
person =new Person();
person.name=this.name;
}catch (Exception e){
new RuntimeException(e);
}
return person;
}
}
然后生产一部荣耀一部分华为
public class Main {
public static void main(String[] args) {
Phone phone =new Phone();
phone.name="Honor";
phone.price=new Float(1.5);
phone.factory=new Factory();
phone.factory.name="三星工厂";
Person person =new Person();
person.name="郭台铭";
phone.factory.Manager=person;
Phone phone1 =phone.Clone();
phone1.name="华为";
System.out.println(phone.toString());
System.out.println(phone1.toString());
}
}
运行结果：
image.png
php示例：（原型模式就是clone来内存拷贝，比new的好处是创建对象快速，适合大对象创建）
/**
* PHP原型模式
* 先创建一个原型对象，然后通过clone原型对象来创建新的对象
* 这样可以避免类创建时重复的初始化操作。
* 浅复制
*/
class Phone {
public $name;
public $price;
public $factory;
public function __construct($name,$price,Factory $factory) {
$this->name = $name;
$this->price = $price;
$this->factory = $factory;
}
public function run()
{
//执行操作
}
}
class Factory {
public $name;
public $manage;
public function __construct($name,Person $manage) {
$this->name = $name;
$this->manage = $manage;
}
}
class Person {
public $name;
public function __construct($name) {
$this->name = $name;
}
}
$manage = new Person('张三');
$factory = new Factory('华为工厂',$manage);
$phone = new Phone("华为",4589.00,$factory);
$phoneClone = clone $phone; //这种方式是浅复制，因为对手机类里的工厂类和人员类修改也会同时修改，深复制的原理就是让所有依赖的类都进行克隆
$phoneClone->name = '小米';
var_dump($phone,$phoneClone);die();
/**
* 深复制
*/
class Phone {
public $name;
public $price;
public $factory;
public function __construct($name,$price,Factory $factory) {
$this->name = $name;
$this->price = $price;
$this->factory = $factory;
}
public function __clone()
{
$this->factory = clone $this->factory;
}
}
class Factory {
public $name;
public $manage;
public function __construct($name,Person $manage) {
$this->name = $name;
$this->manage = $manage;
}
public function __clone()
{
$this->manage = clone $this->manage;
}
}
class Person {
public $name;
public function __construct($name) {
$this->name = $name;
}
}
$manage = new Person('张三');
$factory = new Factory('华为工厂',$manage);
$phone = new Phone("华为",4589.00,$factory);
$phoneClone = clone $phone; //深复制，下面修改工厂和人员不会影响之前的手机类
$phoneClone->name = '小米';
$phoneClone->factory->name = '小米工厂';
$phoneClone->factory->manage->name = '李四';
var_dump($phone,$phoneClone);die();