原型设计模式

原型模式:

通过new产生一个对象需要非常繁琐的数据准备和访问权限，则可以使用原型模式。

java中的克隆技术，以某个对象为原型，复制出新的对象。显然，新的对象具备原型对象的特点。

优势有:效率高（直接克隆，避免了重新执行构造过程步骤）。

克隆类似于new，但不同于new。new创建新的对象属性采用的是默认值。克隆出的对象的属性值完全和原型

相同。并且克隆出的新对象改变不会影响原型对象，然后再修改克隆对象的值。

以多利羊为例实现一个浅克隆

创建一个sheep

package com.gcxzflgl.prototype;

import java.io.Serializable;
import java.util.Date;


public class Sheep implements Cloneable,Serializable {   //1997,英国的克隆羊，多利！
	private String sname;
	private Date birthday;
	
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Object obj = super.clone();  //直接调用object对象的clone()方法！
		return obj;
	}


	public String getSname() {
		return sname;
	}


	public void setSname(String sname) {
		this.sname = sname;
	}


	public Date getBirthday() {
		return birthday;
	}


	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}


	public Sheep(String sname, Date birthday) {
		super();
		this.sname = sname;
		this.birthday = birthday;
	}
	
	public Sheep() {
	}
	
}

创建客户端

package com.gcxzflgl.prototype;

import java.util.Date;

/**
 * 测试原型模式(浅克隆)
 *
 */
public class Client {
	public static void main(String[] args) throws Exception {
		Date date = new Date(12312321331L);
		Sheep s1 = new Sheep("少利",date);
		System.out.println(s1);
		System.out.println(s1.getSname());
		System.out.println(s1.getBirthday());
		
		date.setTime(23432432423L);
		
		System.out.println(s1.getBirthday());
		
		Sheep s2 = (Sheep) s1.clone();
		s2.setSname("多利");
		System.out.println(s2);
		System.out.println(s2.getSname());
		System.out.println(s2.getBirthday());
		
		
	}
}

运行结果：

发现克隆的效果并不是想象那样，接下来实现深克隆

创建多利羊类

package com.gcxzflgl.prototype;

import java.util.Date;


//测试深复制
public class Sheep2 implements Cloneable {   //1997,英国的克隆羊，多利！
	private String sname;
	private Date birthday;
	
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Object obj = super.clone();  //直接调用object对象的clone()方法！
		
		
		//添加如下代码实现深复制(deep Clone)
		Sheep2 s = (Sheep2) obj;
		s.birthday = (Date) this.birthday.clone();  //把属性也进行克隆！
		
		return obj;
	}


	public String getSname() {
		return sname;
	}


	public void setSname(String sname) {
		this.sname = sname;
	}


	public Date getBirthday() {
		return birthday;
	}


	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}


	public Sheep2(String sname, Date birthday) {
		super();
		this.sname = sname;
		this.birthday = birthday;
	}
	
	public Sheep2() {
	}
	
}

创建客户端

package com.gcxzflgl.prototype;

import java.util.Date;

/**
 * 原型模式(深复制)
 *
 */
public class Client2 {
	public static void main(String[] args) throws CloneNotSupportedException {
		Date date = new Date(12312321331L);
		Sheep2 s1 = new Sheep2("少利",date);
		Sheep2 s2 = (Sheep2) s1.clone();   //实现深复制。s2对象的birthday是一个新对象！
		
		
		System.out.println(s1);
		System.out.println(s1.getSname());
		System.out.println(s1.getBirthday());
		
		date.setTime(23432432423L);
		
		System.out.println(s1.getBirthday());
		
		
		s2.setSname("多利");
		System.out.println(s2);
		System.out.println(s2.getSname());
		System.out.println(s2.getBirthday());
		
		
		
	}
}

还可以通过序列化反序列化实现深克隆

package com.gcxzflgl.prototype;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;

/**
 * 原型模式(深复制,使用序列化和反序列化的方式实现深复制)
 *
 */
public class Client3 {
	public static void main(String[] args) throws CloneNotSupportedException, Exception {
		Date date = new Date(12312321331L);
		Sheep s1 = new Sheep("少利",date);
		System.out.println(s1);
		System.out.println(s1.getSname());
		System.out.println(s1.getBirthday());

		
//		使用序列化和反序列化实现深复制
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		ObjectOutputStream    oos = new ObjectOutputStream(bos);
		oos.writeObject(s1);
		byte[] bytes = bos.toByteArray();
		
		ByteArrayInputStream  bis = new ByteArrayInputStream(bytes);
		ObjectInputStream	  ois = new ObjectInputStream(bis);
		
		Sheep s2 = (Sheep) ois.readObject();   //克隆好的对象！
		
		System.out.println("修改原型对象的属性值");  
		date.setTime(23432432423L);
		
		System.out.println(s1.getBirthday());
		
		s2.setSname("多利");
		System.out.println(s2);
		System.out.println(s2.getSname());
		System.out.println(s2.getBirthday());
		
		
	}
}

测试一把创建对象和克隆效率差

package clone;

public class Test {
		public static void testNew(int size){
			long start = System.currentTimeMillis();
			for(int i=0;i<size;i++){
				Laptop t = new Laptop();
			}
			long end = System.currentTimeMillis();
			System.out.println("new的方式创建耗时："+(end-start));
		}
		public static void testClone(int size) throws CloneNotSupportedException{
			long start = System.currentTimeMillis();
			Laptop t = new Laptop();
			for(int i=0;i<size;i++){
				Laptop temp = (Laptop) t.clone();
			}
			long end = System.currentTimeMillis();
			System.out.println("clone的方式创建耗时："+(end-start));
		}
		public static void main(String[] args) throws Exception {
			testNew(1000);
			testClone(1000);
		}
	}
		class Laptop implements Cloneable {  //笔记本电脑
			public Laptop() {
				try {
					Thread.sleep(10);  //模拟创建对象耗时的过程!
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
		}
		@Override
		protected Object clone() throws CloneNotSupportedException {
			Object obj = super.clone();  //直接调用object对象的clone()方法！
			return obj;
		}
}

结果