05-日常工作日的一天：原型模式

5.1模式背景故事

　　以我们日常工作中朝九晚五的一天生活为背景对象。

　　7：00——起床

　　7：30——坐公交车

　　8：30——早餐，到公司

　　12：00——午餐，午休

　　13：30——开始下午工作

　　17：30——下班回家

5.2模式定义

　　原型设计模式（Prototype Pattern），用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。

　　本章讲述的是创建型模式中一种比较特殊的模式——原型模式，这个模式有个最大的特点就是克隆一个现有的对象，这个克隆的结果有两种，一种是浅复制，另一种是深复制。随后会探讨浅复制和深复制的原理。我们都知道创建型模式一般用来创建一个新的对象，然后使用这个对象完成一些对象的操作，我们通过原型模式可以快速地创建一个对象而不需要提供专门的new()操作，这无疑是一种非常有效的方式，可以快速创建一个新的对象。

5.3模式分析

5.3.1原型模式的静态建模

　　原型设计模式的概念就是：用原型实例指定创建对象的种类，即我们一天工作日的生活，如果要生成多天的生活，只要通过复制这些原型创建新的对象就可以了，而不必每次都new()一个实例对象。这样将大大节省创建对象所消耗的各种资源。原型设计模式的结构图如下所示：

　　

　　在上面的原型模式结构图中，首先需要一个原型模式的抽象，接口和抽象类都行，在抽象中含有clone方法，具体的原型实现类具体实现抽象的clone方法，返回具体的类型。客户端使用抽象原型，传入的则是具体的原型对象类型，然后通过原型对象的clone方法产生一个与原型对象一样的克隆对象，而不需要使用new产生对象。

5.4原型模式实现

5.4.1原型的建立

　　注：原型类必须实现Cloneable接口。

package com.prototype.pojo;

/**
 * Created by lsq on 2018/3/14.
 * 日常生活类
 */
public class DayLife implements Cloneable{

    //起床
    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());
    }

    /**
     * clone方法
     * @return
     * @throws CloneNotSupportedException
     */
    @Override
    public DayLife clone(){
        try {
            //调用超类的clone方法（所有类都是Object的子类）
            return (DayLife) super.clone();
        }catch (Exception e){

        }
        return null;
    }
}

5.4.2创建生成原型对象的工厂

1）抽象工厂——ILifeFactory工厂类

package com.prototype.factory;

import com.prototype.pojo.DayLife;

/**
 * Created by lsq on 2018/3/15.
 * 工厂类
 */
public interface ILifeFactory {

    /**
     * 生产DayLife对象
     * @return
     */
    public DayLife getNewInstance();

}

2）具体工厂——LifeFactoryImpl工厂实现类

package com.prototype.factory.impl;

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

/**
 * Created by lsq on 2018/3/15.
 * 工厂实现类
 */
public class LifeFactoryImpl implements ILifeFactory{

    //DayLife实例用于初始化
    private static DayLife dayLife = null;

    /**
     * getNewInstance方法实现：
     * 首先判断dayLife是否为null：
     * 如果是null，则使用new创建一个DayLife对象，同时设置初始内容，并赋值给dayLife对象实例，然后返回；
     * 如果不是null，则使用dayLife的clone方法产生一个新对象并复制给dayLife对象，然后返回
     * @return
     */
    @Override
    public DayLife getNewInstance() {
        //判断dayLife是否为null
        if (dayLife==null){
            //注意：new这个只使用一次
            System.out.println(" new DayLife !");
            dayLife = new DayLife();
            dayLife.setGetUp("7:00起床");
            dayLife.setByBus("7:30坐公交车");
            dayLife.setGetFood("8:30下公交，买早餐，去公司");
            dayLife.setNoon("12:00午餐，午休");
            dayLife.setAfternoonWork("13:30开始下午工作");
            dayLife.setGoHome("17:30下班回家");
            dayLife.setNight("晚上个人时间");
        }else {
            //输出使用clone方法产生的对象
            System.out.println(" clone DayLife !");
            dayLife = dayLife.clone();
        }
        return dayLife;
    }
}

5.4.3运行测试

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

/**
 * Created by lsq on 2018/3/13.
 *
 */
public class MainApp {

    public static void main(String[] args) {
        //创建工厂
        ILifeFactory lifeFactory = new LifeFactoryImpl();
        //打印输出DayLife默认内容
        lifeFactory.getNewInstance().print();

        //再次获得DayLife，修改起床时间
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~");
        DayLife dayLife = lifeFactory.getNewInstance();
        dayLife.setGetUp("早上赖床了，7：10才起床！");
        dayLife.print();

        //再次获得DayLife，修改起床时间
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~");
        DayLife dayLife2 = lifeFactory.getNewInstance();
        dayLife2.setGetUp("早上赖床了，7：20才起床！");
        dayLife2.print();
    }

}

运行结果：

5.5设计原则

　　原型模式的核心是一个clone方法，通过这个方法进行对象的复制，在Java中，提供了一个Cloneable接口来标示这个对象是可复制的。为什么说是“标示”呢？查看Cloneable类源码，会发现该接口中一个方法也没有，这个接口的作用就是一个标示，只有实现该接口的对象才有可能被复制！那，如何从“有可能被复制”变为“可以被复制”呢？方法就是覆盖超类的clone()方法！

　　在使用原型模式的时候，要注意以下几个事项。

1、克隆对象时，对象的构造方法不执行

　　只有new时构造方法才被执行，clone的时候是不会执行构造方法的。为什么呢？因为在使用Object类的clone()方法时，是从内存中直接复制二进制流，重新分配内存块给克隆对象。

2、浅复制和深复制

　　先看一个例子：

import java.util.ArrayList;

/**
 * Created by lsq on 2018/3/15.
 *
 */
public class Test implements Cloneable {

    //私有属性
    private ArrayList<String> nameList = new ArrayList<>();

    //添加内容
    public void add(String s){
        this.nameList.add(s);
    }

    //获得ArrayList对象
    public ArrayList get(){
        return this.nameList;
    }

    //clone方法
    @Override
    public Test clone(){
        try {
            return (Test)super.clone();
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return null;
    }

    public static void main(String[] args) {
        //创建test对象
        Test test = new Test();
        //设置test对象内容
        test.add("aa");
        test.add("bb");
        //打印显示test中的nameList内容
        System.out.println("test:"+test.get());

        //克隆test对象到test2对象
        Test test2 = test.clone();
        //添加“cc”到test2中
        test2.add("cc");
        //打印显示test2中的nameList内容
        System.out.println("test2:"+test2.get());

        //打印显示test中的nameList内容
        System.out.println("test:"+test.get());
    }
}

运行结果：

　　我们发现对克隆对象的修改，影响到了原始对象的内容！这可不是我们想要看到的结果！这就是浅复制所带来的结果。

1）浅复制

　　Object类的clone方法只是复制对象的原始数据类型，如int、float、String等，对于数组和对象引用是不会复制的。因此，浅复制是有风险的。要做到完全复制，就需要深复制了。

2）深复制

　　深复制是指对于对象中的数组和对象引用也做复制的行为，从而达到将对象完全复制的效果。例如，上面的例子中，我们修改一下Test类的clone方法：

    //clone方法
    @Override
    public Test clone(){
        try {
            Test test = (Test)super.clone();
            test.nameList = (ArrayList<String>) this.nameList.clone();
            return test;
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return null;
    }

　　运行结果：

　　从结果来看，test和test2两个对象已经没有任何联系了。从以上内容来看，Object的clone方法只是做浅复制，也就是直接复制类的字段内容，并不管属性字段对象的内容。我们可以在重载的clone方法中进行类的“深复制”，从而得到我们想要的结果。

5.6使用场合

　　1）产生对象过程比较复杂，初始化需要许多资源；

　　2）希望框架原型和产生对象分开时；

　　3）同一个对象可能会供其他调用者同时调用访问时。