原理图
原型模式定义:
用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象.
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或自定义类,注意深拷贝情况