java设计模式之原型模式

ゝ一纸荒年。 2022-07-14 01:10 157阅读 0赞

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

**类型**：创建类模式

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

**类图：**

![SouthEast][]

原型模式的参与角色:  
（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);
    	}
    }

测试结果：

![Center][]  
  
原型模式的优点：  
（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()));
    	}
    
    }

![Center 1][]  
       关于深拷贝和浅拷贝，会发生深拷贝的是java 的 8种基本数据类型和他们的封装类，至于String这个类型需要注意，它是引用数据类型，所以是浅拷贝，有疑惑请看这篇博客： [http://blog.csdn.net/zhangjg\_blog/article/details/18369201][http_blog.csdn.net_zhangjg_blog_article_details_18369201]

[SouthEast]: /images/20220714/1f9513da02ff47fab3db0c4f85e479fe.png
[Center]: /images/20220714/4f4aa68fcd6d437a80aacce82571b01b.png
[Java]: http://lib.csdn.net/base/javaee
[Center 1]: /images/20220714/bc74dfad6d25448e94fd209841805a93.png
[http_blog.csdn.net_zhangjg_blog_article_details_18369201]: http://blog.csdn.net/zhangjg_blog/article/details/18369201