定义:根据已创建的原型实例,通过复制这些原型实例创建新的对象。
</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.同一个对象可能会供其他调用者同时调用访问。
原型设计模式,在一个现有的对象实例基础上建立另外一个新对象,而不是利用类来产生新对象。首先由现有的对象产生大量的共有信息,然后通过复制产生新的副本(注意该副本和原始对象只是拥有相同的数据而已,并不是同一个对象),通过修改部分的细节信息生成个性对象,这样,使创建对象的过称大大简化,省去了过多的繁文缛节,免去了在创建对象时初始化数据的行为。原型模式一般是和工厂方法模式一起使用的,工厂负责提供克隆对象给应用程序的调用者。