大话设计模式笔记（七）の原型模式

举个栗子

问题描述

要求有一个简历类，必须要有姓名，可以设置性别和年龄，可以设置工作经历，最终需要三份简历。

简单实现

简历类

/**
 * 简历类
 * Created by callmeDevil on 2019/7/13.
 */
public class Resume {
    
    private String name;
    private String sex;
    private String age;
    private String timeArea;
    private String company;
    
    public Resume (String name) {
        this.name = name;
    }

    /**
     * 设置个人信息
     * @param sex
     * @param age
     */
    public void setPersonalInfo(String sex, String age){
        this.sex = sex;
        this.age = age;
    }

    /**
     * 设置工作经历
     * @param timeArea
     * @param company
     */
    public void setWorkExperience(String timeArea, String company) {
        this.timeArea = timeArea;
        this.company = company;
    }

    /**
     * 显示
     */
    public void display () {
        System.out.println(String.format("%s %s %s", name, sex, age));
        System.out.println(String.format("工作经历：%s %s", timeArea, company));
    }
 
    // 此处省略get、set方法
    
}

测试

/**
 * 测试
 * Created by callmeDevil on 2019/7/13.
 */
public class Test {

    public static void main(String[] args) {
        Resume resumeA = new Resume("callmeDevil");
        resumeA.setPersonalInfo("男", "24");
        resumeA.setWorkExperience("2018-2019", "伟大的航道");

        Resume resumeB = new Resume("callmeDevil");
        resumeB.setPersonalInfo("男", "24");
        resumeB.setWorkExperience("2018-2019", "伟大的航道");

        Resume resumeC = new Resume("callmeDevil");
        resumeC.setPersonalInfo("男", "24");
        resumeC.setWorkExperience("2018-2019", "伟大的航道");

        resumeA.display();
        resumeB.display();
        resumeC.display();
    }

}

测试结果

callmeDevil 男 24
工作经历：2018-2019 伟大的航道
callmeDevil 男 24
工作经历：2018-2019 伟大的航道
callmeDevil 男 24
工作经历：2018-2019 伟大的航道

存在的问题

跟手写简历没有差别，三份简历需要三份实例化，如果客户需要二十份简历，那就得实例化二十次。

原型模式

定义

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

UML图

代码实现

/**
 * 简历类（实现JDK克隆接口）
 * Created by callmeDevil on 2019/7/13.
 */
public class Resume implements Cloneable{

    private String name;
    private String sex;
    private String age;
    private String timeArea;
    private String company;

    public Resume (String name) {
        this.name = name;
    }

    /**
     * 设置个人信息
     * @param sex
     * @param age
     */
    public void setPersonalInfo(String sex, String age){
        this.sex = sex;
        this.age = age;
    }

    /**
     * 设置工作经历
     * @param timeArea
     * @param company
     */
    public void setWorkExperience(String timeArea, String company) {
        this.timeArea = timeArea;
        this.company = company;
    }

    /**
     * 显示
     */
    public void display () {
        System.out.println(String.format("%s %s %s", name, sex, age));
        System.out.println(String.format("工作经历：%s %s", timeArea, company));
    }

    /**
     * 实现克隆方法，可进行自己的克隆逻辑
     * @return
     * @throws CloneNotSupportedException
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    // 此处省略get、set方法

}

测试

/**
 * 原型模式测试
 * Created by callmeDevil on 2019/7/13.
 */
public class Test {

    public static void main(String[] args) throws CloneNotSupportedException {
        Resume resumeA = new Resume("callmeDevil");
        resumeA.setPersonalInfo("男", "24");
        resumeA.setWorkExperience("2018-2019", "伟大的航道");

        // 只需要调用clone方法就可以实现新简历的生成，并且可以修改新简历的细节
        Resume resumeB = (Resume) resumeA.clone();
        resumeB.setWorkExperience("2019-2020", "新世界");

        Resume resumeC = (Resume) resumeA.clone();
        resumeC.setPersonalInfo("男", "25");

        resumeA.display();
        resumeB.display();
        resumeC.display();
    }

}

测试结果

callmeDevil 男 24
工作经历：2018-2019 伟大的航道
callmeDevil 男 24
工作经历：2019-2020 新世界
callmeDevil 男 25
工作经历：2018-2019 伟大的航道

好处

一般在初始化的信息不发生变化的情况下，克隆是最好的方法。这既隐藏了对象创建的细节，又对性能是大大的提高。
不用重新初始化对象，而是动态的获得对象运行时的状态。

浅复制与深复制

浅复制

在上面这个简历类中，如果字段是值类型（基本数据类型）的，则对该字段直接进行复制；如果是引用类型（String等），则/复制引用/但不/复制引用的对象/；因此，原始对象及其副本引用同一对象。

在此之前，我们先做一个简单的测试

    System.out.println("123" == "123");
    System.out.println("123".equals("123"));
    System.out.println(new String("123") == new String("123"));
    System.out.println(new String("123").equals(new String("123")));

相信有点基础的都知道答案吧？就不卖弄了，直接上结果

true
true
false
true

至于结果为什么会这样，网上也许多分析，此处重点在浅复制的讲解，因此不做过多叙述。

带着上面的理解再看下面的内容。在可克隆的简历类例子中，基本数据类型就没什么好测试的，有兴趣的也可以将年龄改成 int 类型；对于其他 String 类型，就拿 company 字段来说，我们新建一个测试类看下是什么结果

public class Test2 {

    public static void main(String[] args) throws CloneNotSupportedException {
        Resume resumeA = new Resume("callmeDevil");
        resumeA.setWorkExperience("0", "伟大的航道");// 直接声明String

        Resume resumeB = (Resume) resumeA.clone();

        // A 与 B 的公司两种比较
        System.out.println(resumeA.getCompany() == resumeB.getCompany());
        System.out.println(resumeA.getCompany().equals(resumeB.getCompany()));

        resumeA.setWorkExperience("0", new String("伟大的航道"));//new 的方式创建String

        Resume resumeC = (Resume) resumeA.clone();

        // A 与 C 的公司两种比较
        System.out.println(resumeA.getCompany() == resumeC.getCompany());
        System.out.println(resumeA.getCompany().equals(resumeC.getCompany()));
    }

}

比对第一个“123”的例子，稍微思考下在比对下面结果看是否一致

true
true
true
true

是的，这就是浅复制。不论A简历的 company 是直接声明的还是 new 出来的，在clone方法中都只会对 company 字段复制一份引用而已。因此才会出现 “==” 和 “equal()”的结果都是“true”。对于引用类型来说，这个字段所在类实现了clone方法是不够的，它只会对引用类型复制一份引用，那如果连引用类型的字段也要创建一份新的数据，那便是 “深复制”。

浅复制就是，被复制的对象的所有变量都含有与原来对象相同的值，而所有其他对象的引用都仍然只想原来的对象。
深复制把引用对象的变量指向复制过的新对象，而不是援用的被引用的对象。

深复制

此处不纠结于如何对上述 String 的深复制。现将简历类进行改造，把“工作经历”抽出成另一个类 WorkExperience

简历类2

/**
 * 简历类2（深复制）
 * Created by callmeDevil on 2019/7/13.
 */
public class Resume2 implements Cloneable {

    private String name;
    private String sex;
    private String age;
    // 工作经历
    private WorkExperience work;

    public Resume2 (String name) {
        this.name = name;
        this.work = new WorkExperience();
    }
    
    private Resume2(WorkExperience work) throws CloneNotSupportedException {
        this.work = (WorkExperience) work.clone();
    }

    /**
     * 设置个人信息
     * @param sex
     * @param age
     */
    public void setPersonalInfo(String sex, String age){
        this.sex = sex;
        this.age = age;
    }

    /**
     * 设置工作经历
     * @param timeArea
     * @param company
     */
    public void setWorkExperience(String timeArea, String company) {
        // 此处赋值给 work 对象
        this.work.setWorkDate(timeArea);
        this.work.setCompany(company);
    }

    /**
     * 显示
     */
    public void display () {
        System.out.println(String.format("%s %s %s", name, sex, age));
        // 此处显示 work 对象的值
        System.out.println(String.format("工作经历：%s %s", work.getWorkDate(), work.getCompany()));
    }

    /**
     * 实现克隆方法，可进行自己的克隆逻辑
     * @return
     * @throws CloneNotSupportedException
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // 调用私有的构造方法，让“工作经历”对象克隆完成，然后再给这个“简历”对象
        // 相关的字段赋值，最终返回一个深复制的简历对象
        Resume2 obj = new Resume2(this.work);
        obj.setName(this.name);
        obj.setSex(this.sex);
        obj.setAge(this.age);
        return obj;
    }

    // 此处省略get、set方法
    
}

工作经历

/**
 * 工作经历
 * Created by callmeDevil on 2019/7/13.
 */
public class WorkExperience implements Cloneable{

    private String workDate;

    private String company;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    // 此处省略get、set方法
    
}

测试类

/**
 * 深复制测试
 * Created by callmeDevil on 2019/7/13.
 */
public class TestDeepClone {

    public static void main(String[] args) throws CloneNotSupportedException {
        Resume2 resumeA = new Resume2("callmeDevil");
        resumeA.setPersonalInfo("男", "24");
        resumeA.setWorkExperience("2018-2019", "伟大的航道");

        Resume2 resumeB = (Resume2) resumeA.clone();
        resumeB.setWorkExperience("2019-2020", "新世界");

        Resume2 resumeC = (Resume2) resumeA.clone();
        resumeC.setWorkExperience("2020-XXXX", "木叶忍者村");

        resumeA.display();
        resumeB.display();
        resumeC.display();
    }

}

测试结果

callmeDevil 男 24
工作经历：2018-2019 伟大的航道
callmeDevil 男 24
工作经历：2019-2020 新世界
callmeDevil 男 24
工作经历：2020-XXXX 木叶忍者村

可以看到，每次克隆都能将简历类中的工作经历类一同新建，而不是单纯的同个对象进行改变内容。如果是浅复制的实现，那么在相同测试类中会出现什么结果呢？应该能猜到吧，那就是三次输出都是一样的。
对于工作经历类的浅复制实现本文就不描述了，有兴趣的可以自行测试，很简单，需要修改的地方有这么两处：

简历类实现的克隆方法中直接调用 super.clone() 而不需要重写。
取消工作经历类实现克隆接口及其方法。

只需要更改这两处，在相同的测试类中就能看到以下结果

callmeDevil 男 24
工作经历：2020-XXXX 木叶忍者村
callmeDevil 男 24
工作经历：2020-XXXX 木叶忍者村
callmeDevil 男 24
工作经历：2020-XXXX 木叶忍者村

看到此处就不需要解释了吧，每次克隆只是新实例化了“简历”，但三个“简历”中的“工作经历”都是同一个，每次 set值 的时候都必将影响到所有对象，所以输出的工作经历都是相同的。这也同时说明了实现深复制的必要条件：

需要实现深复制的引用类型字段的类（比如上文中的工作经历）必须实现 Cloneable 接口
该字段的所属类（比如上文中的简历）实现的克隆方法中必须对该字段进行克隆与赋值

做到以上两点，即可将原本浅复制的功能转变为深复制。

总结

原型模式无非就是对指定创建的原型实例进行复制，再对新对象另做操作，省去重新 new 的过程。其中复制便分为浅复制与深复制。

posted @ 2019-07-13 14:08 callmeDevil 阅读(490) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

callmeDevil

凝视深渊过久时，深渊将回以凝视。

大话设计模式笔记（七）の原型模式

举个栗子

问题描述

简单实现

简历类

测试

测试结果

存在的问题

原型模式

定义

UML图

代码实现

测试

测试结果

好处

浅复制与深复制

浅复制

深复制

简历类2

工作经历

测试类

测试结果

总结

公告