创建模式--原型模式（JAVA）

原型模式：

原型模式主要针对模型对象类型的克隆，对已有构造好的对象进行复制获取一个新的对象实例。比如我们在获取一个对象并成功赋值后，要传递给多个处理类去处理。 打个比方：吃面是个处理类，面是个模型对象。我们将面从锅里煮熟（模型对象的赋值加工）出来后，分到好几个碗中（克隆）。然后再根据客户的要求对克隆出的面由不同的吃面对象再加工（放辣子，放醋，盐少等等），最后呈现到每个顾客面前的面就都不一样了。

表现形式：

　　1. 简单形式

　　2. 登记形式

1.简单形式

    浅克隆要实现cloneable接口，因克隆是Object的一个native方法，因此父类要重新复写clone方法，调用object的native的clone。因此可自建一个所有原型类的抽象类或者接口，防止原型类未复写clone方法而无法克隆本体。如果对象中套用对象需要在clone中对套用的对象再进行clone，如果对复杂的对象就要用流形式深拷贝，需要实现Serialized接口。

详见：深拷贝和浅拷贝（http://www.cnblogs.com/DennyZhao/p/7016528.html）

 

public abstract class BaseProtoType implements Cloneable {
        /**
         *不能用抽象方法，clone最终调用Object的clone
         */
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

 

public interface Noddles {

    public int longer();
    public int stronger();
    
    public void setDelicate(String str);
}

public class NoddlesProtoType extends BaseProtoType implements Noddles{

    private int longer;
    private int stronger;
    
    @Override
    public int longer() {
        System.out.println("---lonnger-----" + this.longer);
        return this.longer;
    }

    @Override
    public int stronger() {
        System.out.println("---stronger-----" + this.stronger);
        return this.stronger;
    }


    @Override
    public void setDelicate(String str) {
        System.out.println("---delicate-----" + str);
        
    }

    public int getLonger() {
        return longer;
    }
    
    public void setLonger(int longer) {
        this.longer = longer;
    }
    
    public int getStronger() {
        return stronger;
    }
    
    public void setStronger(int stronger) {
        this.stronger = stronger;
    }
}

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException, CloneNotSupportedException {
        NoddlesProtoType noddles = new NoddlesProtoType();
        noddles.setLonger(4);
        noddles.setStronger(8);
        Noddles noddles2 = (Noddles)noddles.clone();
        noddles2.longer();
        noddles2.stronger();
        noddles2.setDelicate("salt");
        Noddles noddles3 = (Noddles)noddles.clone();
        noddles3.longer();
        noddles3.stronger();
        noddles3.setDelicate("chilli");
    }

运行结果：

---lonnger-----4
---stronger-----8
---delicate-----salt
---lonnger-----4
---stronger-----8
---delicate-----chilli

 2. 登记形式

 　　将多个类的克隆由一个管理类统一管理，注册，克隆。

package pattern.creation.factory;

import java.util.HashMap;
import java.util.Map;

/**
 * 这种管理器只能有一个，因此采用单例模式
 * 
 * @author DennyZhao
 * @date 2017年6月20日
 * @version 1.0
 */
public class PrototypeManager {
    
    private Map<String, BaseProtoType> map = new HashMap<String, BaseProtoType>();
    
    private static PrototypeManager propoManager = null;
    /**
     * 私有化
     */
    private PrototypeManager(){
        
    }
    
    /**
     * 创建实例方法
     * @return
     */
    public static PrototypeManager newInstance(){
        if(propoManager == null){
            synchronized(PrototypeManager.class){
                if(propoManager == null){
                    propoManager = new PrototypeManager();
                }
            }
        }
        return propoManager;
    }
    
    /**
     * 存放键值对
     * @param key
     * @param value
     */
    public void setProtoType(String key, BaseProtoType value){
        map.put(key, value);
    }
    
    /**
     * 获取克隆后的对象
     * @param key
     * @return
     * @throws CloneNotSupportedException
     */
    @SuppressWarnings("unchecked")
    public <T> T getCloneProtoType(String key) throws CloneNotSupportedException{
        BaseProtoType baseProtoType = map.get(key);
        if(baseProtoType == null){
            return null;
        }
        return (T)baseProtoType.clone();
    }
}

        PrototypeManager manager = PrototypeManager.newInstance();
        NoddlesProtoType noddles = new NoddlesProtoType();
        noddles.setStronger(5);
        noddles.setDelicate("It's delicious..");
        noddles.setLonger(8);
        RiceProtoType rice = new RiceProtoType();
        rice.setWater("I need more water.....");
        manager.setProtoType("noddle", noddles);
        manager.setProtoType("rice", rice);
        NoddlesProtoType cloneNoddles = manager.getCloneProtoType("noddle");
        RiceProtoType cloneRice = manager.getCloneProtoType("rice");
        System.out.println("-------------");
        cloneNoddles.longer();
        cloneRice.getWater();

---delicate---------delicate
-------------
---lonnger-----8
--water-----I need more water.....

参考文摘：

《JAVA与模式》之原型模式（http://www.cnblogs.com/java-my-life/archive/2012/04/11/2439387.html）