设计模式（六）-原型模式（Prototype Pattern）——通过复制生成实例

叁歲伎倆 2022-06-01 09:39 195阅读 0赞

原型模式（Prototype Pattern）是不根据类来生成实例，而是根据实例来生成新实例的模式。

在以下情况，我们不能根据类来生成实例，而要根据现有的实例来生成新的实例：

**1、对象种类繁多，无法将它们整合到一个类中时；**

需要处理的对象太多，如果将它们分别作为一个类，必须要编写很多的类文件。

**2、难以根据类生成实例时；**

生成实例的过程泰国复杂，很难根据类来生成实例。

**3、想解耦框架与生成的实例时；**

想要让生成实例的方法不依赖于具体的类。

**Product.java**

package com.test.dp.Prototype.Sample.framework;
    
    import java.lang.Cloneable;
    
    //复制功能的接口，实现了Cloneable接口
    public interface Product extends Cloneable {
        public abstract void use(String s);
        public abstract Product createClone();
    }

**Manager.java**

package com.test.dp.Prototype.Sample.framework;
    
    import java.util.*;
    
    //使用Product接口复制实例的类
    public class Manager {
        private HashMap showcase = new HashMap();//存放Project接口
        public void register(String name, Product proto) {//注册Project接口，放入Map
            showcase.put(name, proto);
        }
        public Product create(String protoname) {//通过Project子类实例名称，获取Project接口，java多态性自动调用子类的clone复制方法
            Product p = (Product)showcase.get(protoname);
            return p.createClone();
        }
    }

**MessageBox.java**

package com.test.dp.Prototype.Sample;
    
    import com.test.dp.Prototype.Sample.framework.*;
    
    //实现Product接口，实现复制
    public class MessageBox implements Product {
        private char decochar;
        public MessageBox(char decochar) {
            this.decochar = decochar;
        }
        public void use(String s) {//子类之间有区别的方法
            int length = s.getBytes().length;
            for (int i = 0; i < length + 4; i++) {
                System.out.print(decochar);
            }
            System.out.println("");
            System.out.println(decochar + " "  + s + " " + decochar);
            for (int i = 0; i < length + 4; i++) {
                System.out.print(decochar);
            }
            System.out.println("");
        }
        public Product createClone() {//具体的复制方法
            Product p = null;
            try {
                p = (Product)clone();//调用了Project接口的父类Colneable接口的方法
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return p;
        }
    }

**UnderlinePen.java**

package com.test.dp.Prototype.Sample;
    
    import com.test.dp.Prototype.Sample.framework.*;
    
    //实现Product接口，实现复制
    public class UnderlinePen implements Product {
        private char ulchar;
        public UnderlinePen(char ulchar) {
            this.ulchar = ulchar;
        }
        public void use(String s) {//子类之间有区别的方法
            int length = s.getBytes().length;
            System.out.println("\""  + s + "\"");
            System.out.print(" ");
            for (int i = 0; i < length; i++) {
                System.out.print(ulchar);
            }
            System.out.println("");
        }
        public Product createClone() {
            Product p = null;
            try {
                p = (Product)clone();//调用了Project接口的父类Colneable接口的方法
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return p;
        }
    }

Main.java

package com.test.dp.Prototype.Sample;
    
    import com.test.dp.Prototype.Sample.framework.*;
    
    public class Main {
        public static void main(String[] args) {
            // 准备
            Manager manager = new Manager();
            UnderlinePen upen = new UnderlinePen('~');
            MessageBox mbox = new MessageBox('*');
            MessageBox sbox = new MessageBox('/');
            manager.register("strong message", upen);
            manager.register("warning box", mbox);
            manager.register("slash box", sbox);
    
            // 生成
            Product p1 = manager.create("strong message");
            p1.use("Hello, world.");
            Product p2 = manager.create("warning box");
            p2.use("Hello, world.");
            Product p3 = manager.create("slash box");
            p3.use("Hello, world.");
        }
    }

**执行结果：**  
"Hello, world."  
 ~~~~~~~~~~~~~  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
\* Hello, world. \*  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
/  
/ Hello, world. /  
/

**总结：**

**应用实例**： 1、细胞分裂。 2、JAVA 中的 Object clone() 方法。  
**优点**： 1、性能提高。 2、逃避构造函数的约束。  
**缺点**： 1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 2、必须实现 Cloneable 接口。 3、逃避构造函数的约束。  
**使用场景**： 1、资源优化场景。 2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。 3、性能和安全要求的场景。 4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。 5、一个对象多个修改者的场景。 6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。 7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。  
**注意事项**：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。