原型模式

原型模式(克隆模式/拷贝模式)

-通过new产生一个独享需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
-就是java中的克隆技术，以某个对象为原型，复制出新的对象。显然，新的对象具备原型对象的特点。
-优势有：效率高(直接克隆，避免了重新执行构造过程步骤)
-克隆类似与new，但是不同于new。new撞见新的对象属性采用的是默认值。克隆出对象的属性值完全和原型对象相同。并且克隆出的新对象改变不会影响原型对象。然后，在修改克隆对象的值、

注意：克隆和拷贝是一回事！！

原型模式实现

-Cloneable接口和clone方法
-Prototype模式中实现起来最困难的地方就是内存复制操作，所幸Java中提供了clone()方法替我们做了绝大部分事情

原型模式(浅克隆)

浅克隆：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。

package Prototype;

import java.util.Date;

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

	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;
	}
	
}

package Prototype;

import java.util.Date;

/**
 * 测试原型模式(浅克隆)
 * @author ly
 *
 */
public class Cient {
	public static void main(String[] args) throws Exception {
		Date date = new Date(123554546L);
		Sheep s1 = new Sheep("多利",date);
		
		Sheep s2 = (Sheep) s1.clone();//克隆

		System.out.println(s1);
		System.out.println(s1.getSname());
		System.out.println(s1.getBirthday());
		
		date.setTime(554561656L);//修改时间对象的值
		
		System.out.println(s1.getBirthday());
		
		//克隆对象与原型对象保持一样的值  可以修改其中的值
		s2.setSname("多多利");
		System.out.println(s2);
		System.out.println(s2.getSname());
		System.out.println(s2.getBirthday());
		

浅克隆模式存在的问题

– 被复制的对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都
仍然指向原来的对象。

原型模式(深克隆)

深克隆：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

– 深克隆把引用的变量指向复制过的新对象，而不是原有的被引用的对象。
– 深克隆：让已实现Clonable接口的类中的属性也实现Clonable接口
– 基本数据类型和String能够自动实现深度克隆（值的复制）

原型模式(深克隆实现方式一)

package 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 Sheep2() {
	}
	
	public Sheep2(String sname, Date birthday) {
		super();
		this.sname = sname;
		this.birthday = birthday;
	}

	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;
	}
	
}

package Prototype;

import java.util.Date;

/**
 * 原型模式(深复制)
 * @author ly
 *
 */
public class Client2 {
	public static void main(String[] args) throws Exception {
		Date date = new Date(123554546L);
		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(554561656L);
		
		System.out.println(s1.getBirthday());
		
		//克隆对象与原型对象保持一样的值  可以修改其中的值
		s2.setSname("多多利");
		System.out.println(s2);
		System.out.println(s2.getSname());
		System.out.println(s2.getBirthday());
		
	}
}

原型模式(深克隆实现方式二)

-通过序列化和反序列化实现深复制

package 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 Sheep() {
	}
	
	public Sheep(String sname, Date birthday) {
		super();
		this.sname = sname;
		this.birthday = birthday;
	}

	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;
	}
	
}

package Prototype;

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

/**
 * 原型模式(深复制，使用序列化和反序列化实现深复制)
 * @author ly
 *
 */
public class Client3 {
	public static void main(String[] args) throws Exception {
		Date date = new Date(123554546L);
		Sheep s1 = new Sheep("多利",date);
		System.out.println(s1);
		System.out.println(s1.getSname());
		System.out.println(s1.getBirthday());
		
//		Sheep s2 = (Sheep) s1.clone();
		
		//使用序列化和反序列化实现深复制
		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(55456551656L);
		
		System.out.println(s1.getBirthday());
		
		//克隆对象与原型对象保持一样的值  可以修改其中的值
		s2.setSname("多多利");
		System.out.println(s2);
		System.out.println(s2.getSname());
		System.out.println(s2.getBirthday());
			
	}
}

new方式创建对象与clone方式创建对象比较

package Prototype;

/**
 * 测试普通new方式创建对象和clone方式创建对象的效率差异！
 * 如果需要短时间创建大量对象，并且new的过程比较耗时，则可以考虑使用原型模式！！
 * @author ly
 *
 */
public class Client4 {
	
	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 CloneNotSupportedException {
		testNew(1000);//19531
		testClone(1000);//11
//		System.exit(0);
	}
}

class Laptop implements Cloneable{	//笔记本电脑
	public Laptop() {
		try {
			Thread.sleep(10);//模拟创建对象耗时的过程
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return super.clone();
	}
}```