原型设计模式

原型模式

原型模式是一种对象创建型模式，用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。原型模式允许一个对象再创建另外一个可定制的而对象，无需知道任何创建细节。

UML

Prototype: 抽象原型，给出所有具体原型类所需的接口，定义克隆自己的方法。

ConcretePrototype: 具体原型，被克隆的对象。实现抽象原型接口，实现具体克隆方法

Client: 客户，让一个原型克隆自身从而创建一个新的对象

示例代码

// 抽象原型
interface Prototype extends Cloneable{
    // 声明一个clone()克隆方法
	public Object clone();
}

// 具体原型1
class ConcretePrototype1 implements Prototype{
	String m_attribute1;
    String m_attribute2;
    public ConcretePrototype1(String a1,String a2){
        m_attribute1 = a1;
 		m_attribute2 = a2;       
	}
    public Object clone(){
		Object object = null;
        try{
            // 浅克隆
			object = super.clone();
            // 深克隆
            ((ConcretePrototype1) object).m_attribute2 = new String(this.m_attribute2);
            return object;
        }catch(CloneNotSupportedException e){
            return null;
		}
    }
    // 用于判断对象是否相等
    public boolean equals(Object obj){
		if(this==obj){
			return true;
        }
        if(obj instanceof ConcretePrototype1){
			ConcretePrototype1 p = (ConcretePrototype1) obj;
            System.out.print("浅克隆 m_attribute1");
            System.out.println(p.m_attribute1==this.m_attribute1);
            System.out.print("深克隆 m_attribute2");
            System.out.println(p.m_attribute2==this.m_attribute2);
            return (this.m_attribute1.equals(p.m_attribute1) && this.m_attribute2.equals(p.m_attribute2));
        }
        return false;
    }
}

// 具体原型2
class ConcretePrototype2 implements Prototype{
	int m_attribute1;
    boolean m_attribute2;
    public ConcretePrototype2(int a1,boolean a2){
        m_attribute1 = a1;
 		m_attribute2 = a2;       
	}
    public Object clone(){
		Object object = null;
        try{
			object = super.clone();
            return object;
        }catch(CloneNotSupportedException e){
            return null;
		}
    }
    // 用于判断对象是否相等
    public boolean equals(Object obj){
		if(this==obj){
			return true;
        }
        if(obj instanceof ConcretePrototype2){
			ConcretePrototype2 p = (ConcretePrototype2) obj;
            return (this.m_attribute1==p.m_attribute1 && this.m_attribute2==p.m_attribute2);
        }
        return false;
    }
}

// 客户端
class Client{
	private Prototype prototype;
    public void setPrototype(Prototype p){
		prototype = p;
        System.out.println(prototype);
    }
    public void operation(){
		Prototype p = (Prototype)prototype.clone();
        System.out.println(p);
        System.out.println(prototype==p);
        System.out.println(prototype.equals(p));
    }
}

// 测试
class Test{
	public static void main(String[] args){
        Client c = new Client();
        c.setPrototype(new ConcretePrototype1("abc","123"));
        c.operation();
        c.operation();
        c.setPrototype(new ConcretePrototype2(20,false));
        c.operation();
        c.operation();
    }
}

综述

在原型模式结构中定义了一个抽象原型类，所有的 java 类都继承自 java.lang.Object，而 Object 类提供了一个 clone() 方法，可以将一个 Java 对象复制一份。因此，在 Java 中可以直接使用 Object 提供的 clone() 方法来实现对象的克隆。

能够实现克隆的 Java 类必须实现一个标识接口 Cloneable，表示这个类支持复制。如果一个类没有实现这个接口但是调用了 clone() 方法，java编译程序会抛出异常 CloneNotSupportedException。

通常情况下，一个类包含一些成员对象，在使用原型模式克隆对象时，根据其成员对象是否也克隆，原型模式可以分为两种形式：深克隆与浅克隆。

java语言提供了 clone() 方法将对象复制了一份并返回给调用者。一般而言，clone() 方法满足：

1. 对任何对象 x，都有 x.clone() !=x，即克隆对象与原对象不是同一个对象
2. 对任何对象 x，都有 x.clone().getClass() == x.getClass()，即克隆对象与原对象的类型一致
3. 对任何对象 x 的 equals() 方法定义恰当，那么 x.clone().equals(x) 应该成立。

优点

当创建新的对象实例较为复杂时，使用原型模式可以简化对象的创建过程；

通过一个已有实例可以提高新实例的创建效率；

可以动态增加或减少产品类；

提供了简化的创建结构；

可以使用深克隆的方式保存对象的状态；

缺点

需要为每一个类配备一个克隆方法，而且这个克隆方法需要对类的功能进行通盘考虑，这对全新的类来说是很难的。

对已有的类进行改造时，不一定是件容易的事，必须修改其源代码，违背”开闭原则“。

在实现深克隆时需要编写较为复杂的代码。

使用场景

1. 创建新对象的成本较高，新对象可以通过原型模式对已有对象进行复制来获取，如果时相似对象，则可以对其属性稍作修改。

2. 如果系统要保存对象的状态，而对象的状态变化很小，或者对象本身占内存不大的时候，也可以使用原型模式配合备忘录模式来应用。

相反，如果对象的状态变化很大，或者对象占用的内存很大，那么采用状态模式会比原型模式更好。

对象的成本较高，新对象可以通过原型模式对已有对象进行复制来获取，如果时相似对象，则可以对其属性稍作修改。

2. 如果系统要保存对象的状态，而对象的状态变化很小，或者对象本身占内存不大的时候，也可以使用原型模式配合备忘录模式来应用。

相反，如果对象的状态变化很大，或者对象占用的内存很大，那么采用状态模式会比原型模式更好。

需要避免使用分层次的工厂类来创建分层次的对象，并且类的实例对象只有一个或很少的几个组合状态，通过复制原型对象得到新实例可能比使用构造函数创建一个新实例更加方便。