设计模式－prototype原型模式

有的时候，我们需要一个实例时，并且，当创建一个实例的过程比较复杂或者说是昂贵时，

比如，创建实例的构造函数非常的复杂，在执行这个构造函数时会消耗较长的时间，

同时呢，这个构造函数中的一些信息又没有什么变化

（也就是说创建第一个实例时初始化信息是这样的，创建第二个实例时初始化信息还是还是这样的），

那么直接使用 new 来创建这样一个实例就显得太昂贵了，

最好的解决方法，并不是使用 new 来实例化一个对象，

而是使用克隆，也就是复制，克隆呢，就是通过复制现在已经有了的实例来创建新的实例，

这样有什么好处呢？

很明显，这样实现呢，客户端根本就不知道具体要实例化的是哪一个类，

它只知道是复制了，但具体的实例化情况，它却是一无所知的，这样便对客户端进行了隐藏，

同时，复制一个对象一般情况下会比创建一个对象性能更高（当然有时候也不一定，只是一般情况而已），

其实上面所提到的就是下面要介绍的一个设计模式--原型模式（Prototype），

         

        

原型模式（Prototype） 

定义：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的实例。

换句话说，原型模式就是通过复制现在已经存在的对象来创建一个新的对象。

        

原型模式的结构类图如下：

从上面这副类图中，可以看出，在 AbstractPrototype 中只声明了一个方法，那就是克隆自身。

下面我们就来看一看原型模式的具体实现：

public interface IPrototypeRam extends Cloneable, Serializable{

    public void setName(String name);
    public String getName();

}

public class PrototypeRam implements IPrototypeRam{

    private String name;

    public PrototypeRam() {
        this.name = " this is propotype!";
    }

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }

    public Object clone(){
        Object o = null;
        try{
            o = super.clone();
        }catch(CloneNotSupportedException  e){
            System.out.println(" PrototypeRam is not cloneable");
        }
        return o;
    }
}

//原型管理器部分
public class PrototypeManager {

    private HashMap hm = null;

    private static PrototypeManager pm = null;

    private  PrototypeManager() {
        hm = new HashMap();
    }

    public static synchronized PrototypeManager getPrototypeManager(){
        if(pm == null){
            pm = new PrototypeManager();
        }
        return pm;
    }

    public void register(String name, Object prototype){
        hm.put(name,prototype);
    }

    public void unRegister(String name){
        hm.remove(name);
    }

    public Object getPrototype(String name){
        Object o = null;
        if(hm.containsKey(name)){
            o = hm.get(name);
        }else{
            try{
                o = Class.forName(name).newInstance();
                this.register(name,o);
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        return o;
    }
}


public class PrototypeClient {
    
    PrototypeManager pm = null;

    public PrototypeClient() {
        pm = PrototypeManager.getPrototypeManager();
    }

    public static void main(String args[]){
        PrototypeClient pc = new PrototypeClient();
        String className = null;
        className = "meconsea.PrototypeRam";
        PrototypeRam pr  = null;
        pr = (PrototypeRam)(pc.pm.getPrototype(className));
        if(pr != null){
            PrototypeRam[] pram;
            pram = new PrototypeRam[10];
            for(int i = 0; i < 10; i++){
                pram[i] = (PrototypeRam)pr.clone();
                pram[i].setName(pram[i].getName()+i);
            }
        }
    }
}