设计模式-Prototype

定义:是一种创建型设计模式,它通过复制一个已经存在的实例来返回新的实例,而不是新建实例 被复制的实例就是我们所称的原型,这个原型是可定

定义:是一种创建型设计模式,它通过复制一个已经存在的实例来返回新的实例,而不是新建实例.被复制的实例就是我们所称的原型,这个原型是可定制的.

重点:

1、原型模式主要用于对象的复制,Prototype模式允许一个对象再创建另外一个可定制的对象,根本无需知道任何如何创建的细节。

2、使用原型模式创建对象比直接new一个对象在性能上要好的多,因为Object类的clone方法是一个本地方法,它直接操作内存中的二进制流,特别是复制大对象时,性能的差别非常明显

应用场景:原型模式多用于创建复杂的或者耗时的实例, 因为这种情况下,复制一个已经存在的实例可以使程序运行更高效,或者创建值相等,只是命名不一样的同类数据.

类图:

设计模式-Prototype

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 void show(){

System.out.println("原型模式实现类");

}

}

public class Client {

public static void main(String[] args){

ConcretePrototype cp = new ConcretePrototype();

ConcretePrototype clonecp = (ConcretePrototype)cp.clone();

clonecp.show();

}

}

输出:

原型模式实现类

扩展:

1、clone方法构造的对象是没有调用构造方法的

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 {

private static int i = 0;

public ConcretePrototype() {

i++;

}

public void show() {

System.out.println("原型模式实现类" + i);

}

}

public class Test {

public static void main(String[] args) {

ConcretePrototype cp = new ConcretePrototype();

ConcretePrototype clonecp = (ConcretePrototype) cp.clone();

System.out.println(cp == clonecp);

System.out.println(cp.equals(clonecp));

cp.show();

clonecp.show();

}

}

输出:

false

false

原型模式实现类1

原型模式实现类1

如果是走了构造方法,clonecp.show();应该输出2

2、引用只会进行浅拷贝 (prototype 和 clone 的引用实例:是同一个对象)

class P implements Cloneable {

public P clone() {

P prototype = null;

try {

prototype = (P) super.clone();

} catch (CloneNotSupportedException e) {

e.printStackTrace();

}

return prototype;

}

}

/**

* 引用只会进行浅拷贝,

* @author xinchun.wang

*/

public class A extends P {

private List<String> list = new ArrayList<String>();

private String s = "s";

public static void main(String[] args) {

A a = new A();

A ca = (A)a.clone();

System.out.println(a.equals(ca));//false

System.out.println(a.list == ca.list); //true

a.list.add("aaa");

System.out.println(ca.list); //[aaa]

System.out.println("---------------------------");

System.out.println("a.s: " + a.s);//a.s:s

System.out.println("ca.s: " + ca.s);//ca.s: s

a.s = "b";

System.out.println("a.s: " + a.s);//a.s: b

System.out.println("ca.s: " + ca.s);//ca.s: s

}

}

3、深拷贝与浅拷贝

Object类的clone方法只会拷贝对象中的基本的数据类型(8种基本数据类型byte,char,short,int,long,float,double,boolean),对于数组、容器对象、引用对象等都不会拷贝,这就是浅拷贝。如果要实现深拷贝,必须将原型模式中的引用对象(数组、容器对象)另行拷贝。

举例:

public class Prototype implements Cloneable {  

private ArrayList list = new ArrayList();

public Prototype clone(){

Prototype prototype = null;

try{

prototype = (Prototype)super.clone();

prototype.list = (ArrayList) this.list.clone();

}catch(CloneNotSupportedException e){

e.printStackTrace();

}

return prototype;

}

}

注意:由于ArrayList不是基本类型,所以成员变量list,不会被拷贝,需要我们自己实现深拷贝,幸运的是java提供的大部分的容器类都实现了Cloneable接口。所以实现深拷贝并不是特别困难。

以下是 ArrayList的clone实现,其他引用实现可以参考:

public Object clone() {

try {

ArrayList<E> v = (ArrayList<E>) super.clone();

v.elementData = Arrays.copyOf(elementData, size);

v.modCount = 0;

return v;

} catch (CloneNotSupportedException e) {

// this shouldn't happen, since we are Cloneable

throw new InternalError();

}

}

4、深拷贝的实现举例:

class P implements Cloneable {

}

/**

* @author xinchun.wang

*/

public class A extends P {

@SuppressWarnings("unchecked")

public A clone() {

A prototype = null;

try {

prototype = (A) super.clone();

prototype.list = (List<String>) ((ArrayList<String>)(this.list)).clone();

} catch (CloneNotSupportedException e) {

e.printStackTrace();

}

return prototype;

}

private List<String> list = new ArrayList<String>();

public static void main(String[] args) {

A a = new A();

A ca = a.clone();

a.list.add("aaaa");

System.out.println(a.list); //[aaaa]

System.out.println(ca.list);//[]

}

}

还有一种方式:

序列化实现,把对象写道流里的过程是串行化(Serilization)过程;把对象从流中读出来是并行化(Deserialization)过程. 写在流里的是对象的一个拷贝,然后再从流里读出来重建对象.

public class PrototypeSe implements Serializable {

private String name;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

}

public class NewPrototypeSe implements Serializable {

private String id;

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

private PrototypeSe prototype;

public PrototypeSe getPrototype() {

return prototype;

}

public void setPrototype(PrototypeSe prototype) {

this.prototype = prototype;

}

public Object deepClone(){

try {

ByteArrayOutputStream bo = new ByteArrayOutputStream();

ObjectOutputStream oo = new ObjectOutputStream(bo);

oo.writeObject(this);

ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());

ObjectInputStream oi = new ObjectInputStream(bi);

return oi.readObject();

} catch (IOException | ClassNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

return null;

}

}

}

public class TestDeepClone {

public static void main(String[] args) {

// TODO Auto-generated method stub

PrototypeSe po = new PrototypeSe();

po.setName("test1");

NewPrototypeSe se = new NewPrototypeSe();

se.setPrototype(po);

NewPrototypeSe deepClone = (NewPrototypeSe)se.deepClone();

deepClone.getPrototype().setName("test2");

System.out.println("original name:" + se.getPrototype().getName());

System.out.println("cloned name:" + deepClone.getPrototype().getName());

}

}

结果:

original name:test1

cloned name:test2

未登录用户
全部评论0
到底啦