原型模式

原型模式：

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

　　　java中的克隆技术，以某个对象为原型，复制出新的对象。新的对象具有原型对象的特性。

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

　　克隆类似于new,但是不同于new。new创建新的对象属性采用的是默认值。克隆出的对象的属性

　　值完全和原型对象相同。并且克隆出的新对象改变不会影响原型对象（深克隆不会，浅克隆可能会）。然后，在修改克隆对象的值。

原型模式实现：

　　Cloneable接口的clone方法

　　Prototype模式中实现起来最困难的地方就是内存的复制操作，所幸在Java中为我们提供了clone()方法

　　替我们做了绝大部分事情。

java提供了对于克隆的支持，想要实现克隆，必须实现Cloneable接口，该接口是个空接口，里面没有方法，此外还需要重写Object类的本地clone（）方法。Cloneable接口的代码如下：

　

/*
 * Copyright (c) 1995, 2004, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package java.lang;
/**
 * A class implements the <code>Cloneable</code> interface to
 * indicate to the {@link java.lang.Object#clone()} method that it
 * is legal for that method to make a
 * field-for-field copy of instances of that class.
 * <p>
 * Invoking Object's clone method on an instance that does not implement the
 * <code>Cloneable</code> interface results in the exception
 * <code>CloneNotSupportedException</code> being thrown.
 * <p>
 * By convention, classes that implement this interface should override
 * <tt>Object.clone</tt> (which is protected) with a public method.
 * See {@link java.lang.Object#clone()} for details on overriding this
 * method.
 * <p>
 * Note that this interface does <i>not</i> contain the <tt>clone</tt> method.
 * Therefore, it is not possible to clone an object merely by virtue of the
 * fact that it implements this interface.  Even if the clone method is invoked
 * reflectively, there is no guarantee that it will succeed.
 *
 * @author  unascribed
 * @see     java.lang.CloneNotSupportedException
 * @see     java.lang.Object#clone()
 * @since   JDK1.0
 */
public interface Cloneable {
}

　　一个克隆的实现：

package com.oj;

import java.util.Date;

/**
 * @author We.lxk
 *
 */
public class Sheep implements Cloneable{
	private String sname;
	private Date date;
	
	public Sheep() {
		// TODO Auto-generated constructor stub
	}
	
	public Sheep(String sname, Date date) {
		super();
		this.sname = sname;
		this.date = date;
	}

	public String getSname() {
		return sname;
	}


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


	public Date getDate() {
		return date;
	}


	public void setDate(Date date) {
		this.date = date;
	}


	@Override
	protected Object clone() throws CloneNotSupportedException {
		Object obj = super.clone();		//直接调用object对象的clone()方法
		return obj;
	}
}

　测试代码：

package com.oj;

import java.util.Date;

public class Client {
	public static void main(String[] args) throws Exception {
		Date d = new Date(123123123123123L);
		Sheep s = new Sheep("少利",d);
		System.out.println(s);
		
		
		Sheep s2 = (Sheep) s.clone();
		System.out.println(s2);
		
		System.out.println(s==s2);
		
		Sheep s3 = s;
		System.out.println(s==s3);
		
		s2.setSname("呵呵");
		System.out.println("s: "+s.getSname()+" , "+s.getDate()+"    s2: "+s2.getSname()+" , "+s2.getDate());
		d.setTime(123123123123L);
		System.out.println("s: "+s.getSname()+" , "+s.getDate()+"    s2: "+s2.getSname()+" , "+s2.getDate());
	}
}

　测试输出：

com.oj.Sheep@16bd8ea
com.oj.Sheep@16e1fb1
false
true
s: 少利 , Mon Aug 14 11:32:03 CST 5871 s2: 呵呵 , Mon Aug 14 11:32:03 CST 5871
s: 少利 , Mon Nov 26 08:52:03 CST 1973 s2: 呵呵 , Mon Nov 26 08:52:03 CST 1973

通过输出可以发现，这个实现是浅克隆，s2克隆了s，克隆时只是把s中属性的值（引用类型，指向了一个地址）在堆中另外复制了一份，即把地址复制了一份，所以这个时候s和s2指向了堆中不同的位置，运用==比较时才会false，因为地址不一样了，这个地址所存储的值并没有复制，其中的Date d；仍然等于说是两个对象共用了一份，因此当你直接改变d的值得时候表现为s和s2两个输出的日期同时发生了变化，当你采用s.setDate(new Date(123L))时，这是在堆中新建立了一个Date对象，相当于同d已经脱离了，这是d已经只有s2中的date指向，s中的date指向了这个在堆中新建立的对象了，这时两者才算是脱离了；把s2直接赋值给s3时，两个地址引用指向了同一个堆中对象的位置，这个比较是相等的。

下面进行深克隆

package com.oj;

import java.util.Date;

/**
 * @author We.lxk
 *
 */
public class Sheep2 implements Cloneable{
	private String sname;
	private Date date;
	
	public Sheep2() {
		// TODO Auto-generated constructor stub
	}
	
	public Sheep2(String sname, Date date) {
		super();
		this.sname = sname;
		this.date = date;
	}

	public String getSname() {
		return sname;
	}


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


	public Date getDate() {
		return date;
	}


	public void setDate(Date date) {
		this.date = date;
	}


	@Override
	protected Object clone() throws CloneNotSupportedException {
		Object obj = super.clone();		//直接调用object对象的clone()方法
		Sheep2 s = (Sheep2) obj;
		s.date = (Date) this.date.clone();
		return obj;
	}
}

　测试

package com.oj;

import java.util.Date;

public class Client2 {
	public static void main(String[] args) throws Exception {
		Date d = new Date(123123123123123L);
		Sheep2 s = new Sheep2("少利",d);
		System.out.println(s);
		
		
		Sheep2 s2 = (Sheep2) s.clone();
		System.out.println(s2);
		
		System.out.println(s==s2);
		
		Sheep2 s3 = s;
		System.out.println(s==s3);
		
		s2.setSname("呵呵");
		System.out.println("s: "+s.getSname()+" , "+s.getDate()+"    s2: "+s2.getSname()+" , "+s2.getDate());
		d.setTime(123123L);
		System.out.println("s: "+s.getSname()+" , "+s.getDate()+"    s2: "+s2.getSname()+" , "+s2.getDate());
		s2.setDate(new Date(123123123123L));
		System.out.println("s: "+s.getSname()+" , "+s.getDate()+"    s2: "+s2.getSname()+" , "+s2.getDate());
	}
}

　　输出：

com.oj.Sheep2@16bd8ea
com.oj.Sheep2@16e1fb1
false
true
s: 少利 , Mon Aug 14 11:32:03 CST 5871 s2: 呵呵 , Mon Aug 14 11:32:03 CST 5871
s: 少利 , Thu Jan 01 08:02:03 CST 1970 s2: 呵呵 , Mon Aug 14 11:32:03 CST 5871
s: 少利 , Thu Jan 01 08:02:03 CST 1970 s2: 呵呵 , Mon Nov 26 08:52:03 CST 1973

此时，已经完全将s里的date和s2的date完全分离了，因为在克隆代码里连同date对象一同进行了克隆。输出请遵循上述方法分析理解。

端：