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

原型模式：

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

表现形式：

　　1. 简单形式

　　2. 登记形式

1.简单形式

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

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

 

1 public abstract class BaseProtoType implements Cloneable {
2         /**
3          *不能用抽象方法，clone最终调用Object的clone
4          */
5     @Override
6     public Object clone() throws CloneNotSupportedException {
7         return super.clone();
8     }
9 }

BaseProtoType 

1 public interface Noddles {
2 
3     public int longer();
4     public int stronger();
5     
6     public void setDelicate(String str);
7 }

Noddles

 1 public class NoddlesProtoType extends BaseProtoType implements Noddles{
 2 
 3     private int longer;
 4     private int stronger;
 5     
 6     @Override
 7     public int longer() {
 8         System.out.println("---lonnger-----" + this.longer);
 9         return this.longer;
10     }
11 
12     @Override
13     public int stronger() {
14         System.out.println("---stronger-----" + this.stronger);
15         return this.stronger;
16     }
17 
18 
19     @Override
20     public void setDelicate(String str) {
21         System.out.println("---delicate-----" + str);
22         
23     }
24 
25     public int getLonger() {
26         return longer;
27     }
28     
29     public void setLonger(int longer) {
30         this.longer = longer;
31     }
32     
33     public int getStronger() {
34         return stronger;
35     }
36     
37     public void setStronger(int stronger) {
38         this.stronger = stronger;
39     }
40 }

NoddlesProtoType

 1     public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException, CloneNotSupportedException {
 2         NoddlesProtoType noddles = new NoddlesProtoType();
 3         noddles.setLonger(4);
 4         noddles.setStronger(8);
 5         Noddles noddles2 = (Noddles)noddles.clone();
 6         noddles2.longer();
 7         noddles2.stronger();
 8         noddles2.setDelicate("salt");
 9         Noddles noddles3 = (Noddles)noddles.clone();
10         noddles3.longer();
11         noddles3.stronger();
12         noddles3.setDelicate("chilli");
13     }

测试方法

运行结果：

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

 2. 登记形式

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

 1 package pattern.creation.factory;
 2 
 3 import java.util.HashMap;
 4 import java.util.Map;
 5 
 6 /**
 7  * 这种管理器只能有一个，因此采用单例模式
 8  * 
 9  * @author DennyZhao
10  * @date 2017年6月20日
11  * @version 1.0
12  */
13 public class PrototypeManager {
14     
15     private Map<String, BaseProtoType> map = new HashMap<String, BaseProtoType>();
16     
17     private static PrototypeManager propoManager = null;
18     /**
19      * 私有化
20      */
21     private PrototypeManager(){
22         
23     }
24     
25     /**
26      * 创建实例方法
27      * @return
28      */
29     public static PrototypeManager newInstance(){
30         if(propoManager == null){
31             synchronized(PrototypeManager.class){
32                 if(propoManager == null){
33                     propoManager = new PrototypeManager();
34                 }
35             }
36         }
37         return propoManager;
38     }
39     
40     /**
41      * 存放键值对
42      * @param key
43      * @param value
44      */
45     public void setProtoType(String key, BaseProtoType value){
46         map.put(key, value);
47     }
48     
49     /**
50      * 获取克隆后的对象
51      * @param key
52      * @return
53      * @throws CloneNotSupportedException
54      */
55     @SuppressWarnings("unchecked")
56     public <T> T getCloneProtoType(String key) throws CloneNotSupportedException{
57         BaseProtoType baseProtoType = map.get(key);
58         if(baseProtoType == null){
59             return null;
60         }
61         return (T)baseProtoType.clone();
62     }
63 }

PrototypeManager

 1         PrototypeManager manager = PrototypeManager.newInstance();
 2         NoddlesProtoType noddles = new NoddlesProtoType();
 3         noddles.setStronger(5);
 4         noddles.setDelicate("It's delicious..");
 5         noddles.setLonger(8);
 6         RiceProtoType rice = new RiceProtoType();
 7         rice.setWater("I need more water.....");
 8         manager.setProtoType("noddle", noddles);
 9         manager.setProtoType("rice", rice);
10         NoddlesProtoType cloneNoddles = manager.getCloneProtoType("noddle");
11         RiceProtoType cloneRice = manager.getCloneProtoType("rice");
12         System.out.println("-------------");
13         cloneNoddles.longer();
14         cloneRice.getWater();

测试

1 ---delicate---------delicate
2 -------------
3 ---lonnger-----8
4 --water-----I need more water.....

结果

 

 

 

 

 

 

参考文摘：

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

 

    

 

 

转载于:https://www.cnblogs.com/DennyZhao/p/7053416.html