java设计模式之原型模式_java ptototype 模式-CSDN博客

定义：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

类型：创建类模式

使用场景：例如：工作流实例的重建、复杂数据实体的复制

类图：

原型模式的参与角色:
（1）客户角色：客户类提出创建对象的请求。
（2）抽象原型角色：这是一个抽象角色，通常由一个java接口或抽象类实现，具体原型都需要实现该接口。
（3）具体原型角色：客户端所需要的被复制的对象。

实例一、

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();  
        for(int i=0; i< 10; i++){  
            ConcretePrototype clonecp = (ConcretePrototype)cp.clone();  
            clonecp.show();  
        }  
    }  
}

实例二、

package com.deppon.tps.module.PrototypePatternTest;
class Prototype implements Cloneable{
	private String name;
	 //构造函数
	public Prototype(String name){
		this.name=name;
	}
	//覆盖Object的clone()方法
	public Prototype clone(){
		Prototype protoype=null;
		try {
			protoype=(Prototype) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return protoype;
		
	}
	//重写toString()方法
	public String toString(){
		return "his name is "+name;
	}
}
public class PrototypeTest1 {
	public static void main(String[] arg){
		Prototype concretePototype=new Prototype("liuhai");
		System.out.println("下面直接默认调用了String类里面的“toString()”");
		System.out.println(concretePototype.toString());
		Prototype ccpototype=(Prototype)concretePototype.clone();
		 System.out.println("下面是原型模式构造出来的实例结果:");
		System.out.println(ccpototype);
	}
}

测试结果：

原型模式的优点：
（1）根据客户端要求实现动态创建对象，客户端不需要知道对象的创建细节，便于代码的维护和扩展。
（2）使用原型模式创建对象比直接new一个对象在性能上要好的多，因为Object类的clone方法是一个本地方法，它直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显。所以在需要重复地创建相似对象时可以考虑使用原型模式。比如需要在一个循环体内创建对象，假如对象创建过程比较复杂或者循环次数很多的话，使用原型模式不但可以简化创建过程，而且可以使系统的整体性能提高很多。

（3）原型模式类似于工厂模式，但它没有了工厂模式中的抽象工厂和具体工厂的层级关系，代码结构更清晰和简单。

原型模式的注意事项：
（1）使用原型模式复制对象不会调用类的构造方法。因为对象的复制是通过调用Object类的clone方法来完成的，它直接在内存中复制数据，因此不会调用到类的构造方法。不但构造方法中的代码不会执行，甚至连访问权限都对原型模式无效。还记得单例模式吗？单例模式中，只要将构造方法的访问权限设置为 private型，就可以实现单例。但是clone方法直接无视构造方法的权限，所以，单例模式与原型模式是冲突的。
（2）在使用时要注意深拷贝与浅拷贝的问题。clone方法只会拷贝对象中的基本的数据类型，对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝。

以下深拷贝实例一：

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接口。所以实现深拷贝并不是特别困难。

以下深拷贝实例二：

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

package com.deppon.tps.module.PrototypePatternTest;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class Dog implements Cloneable,Serializable {
	private static final long serialVersionUID = -2050795770781171788L;
	private String name;
	Eye eye;
	public Dog(Eye eye) {
		this.eye=eye;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name=name;
	}
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Dog dog;
		dog=(Dog) super.clone();
		return dog;
	}
	/* 深复制 */  
    public Object deepClone() throws IOException, ClassNotFoundException {  
        /* 写入当前对象的二进制流 */  
        ByteArrayOutputStream bos = new ByteArrayOutputStream();  
        ObjectOutputStream oos = new ObjectOutputStream(bos);  
        oos.writeObject(this);  
        /* 读出二进制流产生的新对象 */  
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());  
        ObjectInputStream ois = new ObjectInputStream(bis);  
        return ois.readObject();  
    } 
}
class Eye implements Serializable{
	private static final long serialVersionUID = -2723012171722328322L;
	String name;
	public Eye(String name) {
		this.name=name;
	}
}
public class PtototypeTest2 {
	/**
	 * equal强调内容是否相同
     * =强调地址是否相同
	 * @param args
	 * @throws ClassNotFoundException 
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		Dog dog = new Dog(new Eye("红眼睛"));
		dog.setName("狗一");
		
		System.out.println("-----------------深复制--------------");
		Dog object2 = (Dog) dog.deepClone();
		object2.eye.name="绿眼睛";
		object2.setName("狗二");
		
		System.out.println(dog.eye.name);
		System.out.println(object2.eye.name);
		
		System.out.println(dog.getName());
		System.out.println(object2.getName());
		
		System.out.println(object2.equals(dog));
		System.out.println(object2==dog);
		System.out.println(object2.getClass().equals(dog.getClass()));
	}

}