原型模式-1

定义：根据已创建的原型实例，通过复制这些原型实例创建新的对象。

</pre><pre>

原型类：

package com.demo.prototype.pojo;

public class DayLife implements Cloneable {
	
	
	public DayLife() {
		//测试克隆过程中是否执行构造方法
		System.out.println("--执行构造方法了！--");
	}

	//起床
	private String getUp;
	//坐公交
	private String byBus;
	//下车，买早餐
	private String getFood;
	//中午小憩
	private String noon;
	//下午开始工作
	private String afternoonWork;
	//下班回家
	private String goHome;
	//晚上休闲
	private String night;
	
	public String getGetUp() {
		return getUp;
	}
	public void setGetUp(String getUp) {
		this.getUp = getUp;
	}
	public String getByBus() {
		return byBus;
	}
	public void setByBus(String byBus) {
		this.byBus = byBus;
	}
	public String getGetFood() {
		return getFood;
	}
	public void setGetFood(String getFood) {
		this.getFood = getFood;
	}
	public String getNoon() {
		return noon;
	}
	public void setNoon(String noon) {
		this.noon = noon;
	}
	public String getAfternoonWork() {
		return afternoonWork;
	}
	public void setAfternoonWork(String afternoonWork) {
		this.afternoonWork = afternoonWork;
	}
	public String getGoHome() {
		return goHome;
	}
	public void setGoHome(String goHome) {
		this.goHome = goHome;
	}
	public String getNight() {
		return night;
	}
	public void setNight(String night) {
		this.night = night;
	}
	
	//打印输出日常生活信息
	public void print(){
		System.out.println(this.getGetUp());
		System.out.println(this.getByBus());
		System.out.println(this.getGetFood());
		System.out.println(this.getNoon());
		System.out.println(this.getAfternoonWork());
		System.out.println(this.getGoHome());
		System.out.println(this.getNight());
	}
	
	/**
	 * 重写父类object的克隆方法
	 */
	@Override
	public DayLife clone(){
		try {
			return (DayLife)super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return null;
		
	}
	
}

生产原型的工厂：

package com.demo.prototype.factory;

import com.demo.prototype.pojo.DayLife;

/**
 * 工厂类
 * @author DELL
 *
 */
public interface ILifeFactory {
	//生产DayLife对象
	public DayLife getNewInstance();

}

原型工厂实现类：

package com.demo.prototype.factory.impl;

import com.demo.prototype.factory.ILifeFactory;
import com.demo.prototype.pojo.DayLife;

public class LifeFactoryImpl implements ILifeFactory {
	
	private static DayLife dayLife = null;

	public DayLife getNewInstance() {
		
		if(dayLife == null){
			dayLife = new DayLife();
			System.out.println(" New Day !");
			dayLife.setGetUp("7:00点起床");
			dayLife.setByBus("7:30坐公交车");
			dayLife.setGetFood("8:30下车买早餐到公司");
			dayLife.setNoon("12:00午餐,休息一会");
			dayLife.setAfternoonWork("13:00开始下午的工作");
			dayLife.setGoHome("17:30下班");
			dayLife.setNight("晚上休闲娱乐");
		}else{
			System.out.println(" Clone Day ！");
			dayLife = dayLife.clone();
		}
		return dayLife;
	}

}

测试类：

package com.demo.prototype.test;

import com.demo.prototype.factory.ILifeFactory;
import com.demo.prototype.factory.impl.LifeFactoryImpl;
import com.demo.prototype.pojo.DayLife;

public class Client {
	public static void main(String args[]){
		
		ILifeFactory lifeFactory = new LifeFactoryImpl();
		lifeFactory.getNewInstance().print();
		
		System.out.println("-------------");
		DayLife dayLife1 = lifeFactory.getNewInstance();
		dayLife1.setGetUp("早上赖床了，7:15起床");
		dayLife1.print();
		
		System.out.println("-------------");
		DayLife dayLife2 = lifeFactory.getNewInstance();
		dayLife2.setGetUp("早上起晚了，7:30起床");
		dayLife2.print();
	}
}

测试结果：

--执行构造方法了！--
 New Day !
7:00点起床
7:30坐公交车
8:30下车买早餐到公司
12:00午餐,休息一会
13:00开始下午的工作
17:30下班
晚上休闲娱乐
-------------
 Clone Day ！
早上赖床了，7:15起床
7:30坐公交车
8:30下车买早餐到公司
12:00午餐,休息一会
13:00开始下午的工作
17:30下班
晚上休闲娱乐
-------------
 Clone Day ！
早上起晚了，7:30起床
7:30坐公交车
8:30下车买早餐到公司
12:00午餐,休息一会
13:00开始下午的工作
17:30下班
晚上休闲娱乐

可以看到，只有第一个DayLife对象才是通过new创建的，第二个和第三个DayLife对象都是通过clone克隆生成的！这就是原型设计模式：通过一个已存在的对象，克隆生产一个新的对象，在此基础上修改部分内容，形成全新对象实体！

由以上代码也可以看出，只有new时构造方法才被执行，clone的时候是不会执行构造方法的。为什么呢？原因很简单，在使用Object类的clone方法时，是从内存中直接复制二进制流，重新分配内存块给克隆对象，所以构造方法不被执行也在情理之中。

使用原型模式创建对象比直接new一个对象在性能上要好的多，因为Object类的clone方法是一个本地方法，它直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显。

使用原型模式的另一个好处是简化对象的创建，使得创建对象就像我们在编辑文档时的复制粘贴一样简单。

原型设计模式使用场合：
1.产生对象的过程比较复杂，初始化需要许多资源时；
2.希望框架原型和产生对象分开时；
3.同一个对象可能会供其他调用者同时调用访问。
原型设计模式，在一个现有的对象实例基础上建立另外一个新对象，而不是利用类来产生新对象。首先由现有的对象产生大量的共有信息，然后通过复制产生新的副本（注意该副本和原始对象只是拥有相同的数据而已，并不是同一个对象），通过修改部分的细节信息生成个性对象，这样，使创建对象的过称大大简化，省去了过多的繁文缛节，免去了在创建对象时初始化数据的行为。原型模式一般是和工厂方法模式一起使用的，工厂负责提供克隆对象给应用程序的调用者。