sheng的学习笔记-设计模式-原型模式

原理图

 

 原型模式定义:
用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象.
Prototype 模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。

一个prototype类

package design.prototype;

import java.util.ArrayList;

public class AbstractSpoon implements Cloneable {
    String spoonName;
    // 这个是浅拷贝，如果深拷贝
    private ArrayList<String> images = new ArrayList<String>();

    // 在clone中调用了ArrayList的clone方法，对于string是深拷贝，但自定义类要自行实现深拷贝逻辑
    private ArrayList<String> cloneImages = new ArrayList<String>();

    public String getSpoonName() {
        return spoonName;
    }

    public void setSpoonName(String spoonName) {
        this.spoonName = spoonName;
    }

    public ArrayList<String> getImages() {
        return images;
    }

    public void setImages(ArrayList<String> images) {
        this.images = images;
    }

    public ArrayList<String> getCloneImages() {
        return cloneImages;
    }

    public void setCloneImages(ArrayList<String> cloneImages) {
        this.cloneImages = cloneImages;
    }

    @Override
    public AbstractSpoon clone() {
        AbstractSpoon object = null;
        try {
            object = (AbstractSpoon) super.clone();
            object.setCloneImages((ArrayList<String>) (this.getCloneImages().clone()));
        } catch (CloneNotSupportedException e) {
            System.out.println("AbstractSpoon is not Cloneable");
        }
        return object;
    }

    @Override
    public String toString() {
        return "AbstractSpoon{" +
                "spoonName='" + spoonName + '\'' +
                ", images=" + images +
                ", cloneImages=" + cloneImages +
                '}';
    }
}

 一个实现类：

package design.prototype;

import java.util.ArrayList;
import java.util.Arrays;

public class SoupSpoon extends AbstractSpoon {
    public SoupSpoon() {
        setSpoonName("soup spoon");
        setImages(new ArrayList<String>(Arrays.asList("soup spoon image 1", "soup spoon image 2")));
        setCloneImages(new ArrayList<String>(Arrays.asList("soup clone spoon image 1", "soup clone spoon image 2")));
    }

}

使用：

package design.prototype;

/**
 * 原型模式定义:
 * 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象.
 * Prototype 模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个
 * 原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。
 * 注意，代码中{@link AbstractSpoon}的images是list,浅拷贝，更改这个list指向的值后，拷贝的对象值也会响应改变
 */
public class Prototype {

    public static void main(String[] args) {
        AbstractSpoon spoon = new SoupSpoon();
        AbstractSpoon spoon2 = (AbstractSpoon) spoon.clone();
        // 克隆后打印2个对象内容
        System.out.println("spoon: " + spoon);
        System.out.println("spoon2: " + spoon2);

        // 在images的list中添加第三个元素，修改第二个元素值
        spoon.setSpoonName("change spoon name");
        spoon.getImages().add("spoon image 3");
        spoon.getImages().set(1, "change spoon image 2");
        spoon.getCloneImages().add("spoon clone image 3");
        spoon.getCloneImages().set(1, "change spoon clone image 2");

        System.out.println("change the value");
        System.out.println(spoon);
        System.out.println(spoon2);
    }
}

结果：

 Prototype 模式通过复制原型（ Prototype）而获得新对象创建的功能，这里 Prototype 本
身就是“对象工厂”（ 因为能够生产对象） ， 实际上 Prototype 模式和 Builder 模式、
AbstractFactory 模式都是通过一个类（对象实例） 来专门负责对象的创建工作（工厂对象），
它们之间的区别是： Builder 模式重在复杂对象的一步步创建（并不直接返回对象） ，
AbstractFactory 模式重在产生多个相互依赖类的对象，而 Prototype 模式重在从自身复制自
己创建新类。

另外注意clone时深拷贝和浅拷贝，如果是基础类型，可以不用关注，如果是list，map或自定义类，注意深拷贝情况