原型模式

---

用原型实例指定创建对象的，拷贝这些对象生成新的对象进行使用。

也可以直接进行new一个对象，但是当对象的构造复杂时，new的效率会很低，使用clone更好

new适用于简单的构造

clone适用于复杂的构造

应用场景

• 资源消耗大的对象
• 节省资源，比如在for循环内创建相同的对象
• 一个对象要让其他人使用，并且使用过程中要改变这个对象的某些属性，可考虑将原有对象拷贝，并且修改需要改变的属性，在进行使用
• 对象结构复杂的情况使用拷贝

浅拷贝代码实现

<font color=#0099ff size=3 face="黑体">原型对象实现Cloneable接口</font>（默认是浅拷贝）

class Prototype implements Cloneable {

    public Prototype clone() {
        Prototype prototype = null;
        try {
            prototype = (Prototype) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return prototype;
    }


}

原型对象具体的内容实现

class ConcretePrototype extends Prototype {

    public String name;
    public ArrayList<String> list = new ArrayList<>();

    public ConcretePrototype() {
        System.out.println("执行了ConcretePrototype构造函数");
    }

    @Override
    public String toString() {
        return "ConcretePrototype{" +
                "name='" + name + '\'' +
                ", list=" + list +
                '}';

    }


    public void show() {
        System.out.println("原型模式实现类");
    }
}   

使用方式

  ConcretePrototype cp = new ConcretePrototype();
        cp.name = "原始数据";
        for (int i = 0; i < 10; i++) {
            cp.list.add(i, String.valueOf(i));//填充数据
        }
        ConcretePrototype cloneConcretePrototype = (ConcretePrototype) cp.clone();//实现拷贝
        cloneConcretePrototype.name = "拷贝数据";
        System.out.println(cp.toString());
        System.out.println(cloneConcretePrototype.toString());
        

显示结果:

执行了ConcretePrototype构造函数
ConcretePrototype{name='原始数据', list=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}
ConcretePrototype{name='拷贝数据', list=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}

<font color=#0099ff size=3 face="黑体">原型对象不实现Cloneable接口</font>（默认是浅拷贝）

其实就是把cloneable接口的内容手动实现一次

class ConcretePrototype2 {

    public String name;
    public ArrayList<String> list = new ArrayList<>();

    public ConcretePrototype2() {
        System.out.println("执行了ConcretePrototype2构造函数");
    }

    public ConcretePrototype2 clone() {
       //手动new对象进行赋值
        concretePrototype2 concretePrototype2 = new ConcretePrototype2();
        concretePrototype2.name = this.name;
        concretePrototype2.list = this.list;
        return concretePrototype2;
    }


    @Override
    public String toString() {
        return "ConcretePrototype2{" +
                "name='" + name + '\'' +
                ", list=" + list +
                '}';

    }


    public void show() {
        System.out.println("原型模式实现类");
    }
}

调用方式

 ConcretePrototype2 cp = new ConcretePrototype2();
        cp.name = "原始数据";
        for (int i = 0; i < 10; i++) {
            cp.list.add(i, String.valueOf(i));//填充数据
        }
        ConcretePrototype2 cloneConcretePrototype = (ConcretePrototype2) cp.clone();//实现拷贝
        cloneConcretePrototype.name = "拷贝数据";
        System.out.println(cp.toString());
        System.out.println(cloneConcretePrototype.toString());

显示结果

执行了ConcretePrototype2构造函数
执行了ConcretePrototype2构造函数
ConcretePrototype2{name='原始数据', list=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}
ConcretePrototype2{name='拷贝数据', list=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}

构造函数执行了两次，说明了cloneable接口的复制是不会执行2次构造的，直接new对象则会调用2次构造。

测试

修改复制后的数据

 ConcretePrototype2 cp = new ConcretePrototype2();
        cp.name = "原始数据";
        for (int i = 0; i < 10; i++) {
            cp.list.add(i, String.valueOf(i));//填充数据
        }
        ConcretePrototype2 cloneConcretePrototype = (ConcretePrototype2) cp.clone();//实现拷贝
        cloneConcretePrototype.name = "拷贝数据";
        cloneConcretePrototype.list.add("追加测试数据");
        System.out.println(cp.toString());
        System.out.println(cloneConcretePrototype.toString());

显示结果

执行了ConcretePrototype2构造函数
执行了ConcretePrototype2构造函数
ConcretePrototype2{name='原始数据', list=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 追加测试数据]}
ConcretePrototype2{name='拷贝数据', list=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 追加测试数据]}

【追加测试数据无论是原型还是拷贝后的对象都有这个数据】

问题原因：深拷贝-浅拷贝

Cloneable接口默认实现的是浅拷贝，对于基本类型会进行拷贝，但是对于引用类型（集合，数据，对象）等clone仅仅代表指向了同一个内存地址，所以修改一个两个都会变化。

解决方案：在引用类型的具体数据类型在进行一次clone，将浅拷贝处理为深拷贝

深拷贝代码实现

代码如下

  public ConcretePrototype2 clone() {
        //手动new对象进行赋值
//        ConcretePrototype2 concretePrototype2 = new ConcretePrototype2();
//        concretePrototype2.name = this.name;
//        concretePrototype2.list = this.list;
//        return concretePrototype2;
        
        //将具体的集合修改为深拷贝
        ConcretePrototype2 concretePrototype2 = new ConcretePrototype2();
        concretePrototype2.name = this.name;
        concretePrototype2.list = (ArrayList<String>) this.list.clone();

        return concretePrototype2;

    }
    

显示结果

执行了ConcretePrototype2构造函数
执行了ConcretePrototype2构造函数
ConcretePrototype2{name='原始数据', list=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}
ConcretePrototype2{name='拷贝数据', list=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 追加测试数据]}

应证我们的想法，对于集合，数组，对象等，如果要新增数据，需要对其重写更改具体的数据类型。

总结

原型模式可以避免构造复杂的对象时的资源消耗问题，提升创建对象的效率。
可以保护原始对象的数据安全性
clone是二进制流,对于复杂的构造对象，性能提升明显，但是对于简单的构造没必要使用clone

github代码地址