选择23种设计模式之一:原型模式
概述
用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。
解决的问题
使用原型模式创建对象比直接new一个对象在性能上要好的多,因为Object类的clone方法是一个本地方法,它直接操作内存中的二进制流,特别是复制大对象时,性能的差别非常明显。
使用原型模式的另一个好处是简化对象的创建,使得创建对象就像我们在编辑文档时的复制粘贴一样简单。
因为以上优点,所以在需要重复地创建相似对象时可以考虑使用原型模式。比如需要在一个循环体内创建对象,假如对象创建过程比较复杂或者循环次数很多的话,使用原型模式不但可以简化创建过程,而且可以使系统的整体性能提高很多。
模式中的角色
原型类的特点:
- 实现Cloneable接口。在java语言有一个Cloneable接口,它的作用只有一个,就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中,只有实现了这个接口的类才可以被拷贝,否则在运行时会抛出CloneNotSupportedException异常。
- 重写Object类中的clone方法。Java中,所有类的父类都是Object类,Object类中有一个clone方法,作用是返回对象的一个拷贝,但是其作用域protected类型的,一般的类无法调用,因此,Prototype类需要将clone方法的作用域修改为public类型。
java剖析如下:
浅拷贝就是指两个对象共同拥有同一个值,一个对象改变了该值,也会影响到另一个对象。深拷贝就是两个对象的值相等,但是互相独立。
例如:
Person p = new Person();
p.setName("person1");
Person p2 = p;
System.out.println(p.getName());
System.out.println(p2.getName());
p2.setName("gggggg");
System.out.println(p.getName());
System.out.println(p2.getName());
两个对象的值只有有一个改变了,其他的就会改变。这就是浅拷贝。
1.区分深浅拷贝
Object类的clone方法只会拷贝对象中的基本的数据类型,对于数组、容器对象、引用对象等都不会拷贝,这就是浅拷贝。如果要实现深拷贝,必须将原型模式中的数组、容器对象、引用对象等另行拷贝。
1.浅拷贝
package com.lgy.prototype;
public class Person implements Cloneable {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
2.深拷贝
package com.lgy.prototype;
import java.util.ArrayList;
import java.util.List;
public class Person implements Cloneable {
private String name;
private Son son = new Son();
public Son getSon() {
return son;
}
public void setSon(Son son) {
this.son = son;
}
private ArrayList <String> list;
public ArrayList<String> getList() {
return list;
}
public void setList(ArrayList<String> list) {
this.list = list;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public Object clone() throws CloneNotSupportedException {
Person prototype = null;
try{
System.out.println("clone");
prototype = (Person)super.clone();
this.list = (ArrayList<String>) this.list.clone();
this.son = (Son) this.son.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return prototype;
}
}
此时list和son做了深拷贝,若不进行深拷贝,clone后的对象,会随着母对象改变son和list的值的改变而改变。
2.与单例模式的冲突
package com.lgy.prototype;
public class Singleton implements Cloneable {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton() {
}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
@Override
public Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
return super.clone();
}
}
Singleton instance = Singleton.getInstance();
instance.setName("hahaha");
Singleton clone = (Singleton) instance.clone();
instance.setName("ggggggg");
System.out.println(instance.getName());
System.out.println(clone.getName());
单例模式也能实现拷贝,原型模式是在内存中实现对对象的拷贝的,不需要经过构造函数就可以完成。
模式总结
优点
使用原型模式创建对象比直接new一个对象在性能上要好的多,因为Object类的clone方法是一个本地方法,它直接操作内存中的二进制流,特别是复制大对象时,性能的差别非常明显。
缺点
clone只是对基本数据类型进行拷贝,但是对引用类型还没进行拷贝。依赖关系并未完全解除,抽象通知者依旧依赖抽象的观察者。
适用场景
使用原型模式的另一个好处是简化对象的创建,使得创建对象就像我们在编辑文档时的复制粘贴一样简单。