设计模式:原型模式(Prototype)

以前听过这样一句话:“程序员的最高境界就是Ctrl+C、Ctrl+V”,我们先不论这句话的对错,就论这个过程,这个过程我们都知道无非就是复制一个对象,然后将其不断地粘贴。这样的过程我们可以将其称之为“克隆”。再如我们应聘的时候打印了那么多的简历。

克隆我们都清楚,就是用一个物体复制若干个一模一样物体。同样,在面向对象系统中,我们同样可以利用克隆技术来克隆出若干个一模一样的对象。在应用程序中,有些对象比较复杂,其创建过程过于复杂,而且我们又需要频繁的利用该对象,如果这个时候我们按照常规思维new该对象,那么务必会带来非常多的麻烦,这个时候我们就希望可以利用一个已有的对象来不断对他进行复制就好了,这就是编程中的“克隆”。这里原型模式就可以满足我们的“克隆”,在原型模式中我们可以利用过一个原型对象来指明我们所要创建对象的类型,然后通过复制这个对象的方法来获得与该对象一模一样的对象实例。这就是原型模式的设计目的。

一、模式定义

通过前面的简单介绍我们就可以基本确定原型模式的定义了。所谓原型模式就是用原型实例指定创建对象的种类,并且通过复制这些原型创建新的对象。

在原型模式中,所发动创建的对象通过请求原型对象来拷贝原型对象自己来实现创建过程,当然所发动创建的对象需要知道原型对象的类型。这里也就是说所发动创建的对象只需要知道原型对象的类型就可以获得更多的原型实例对象,至于这些原型对象时如何创建的根本不需要关心。

讲到原型模式了,我们就不得不区分两个概念:深拷贝、浅拷贝。

浅拷贝:使用一个已知实例对新创建实例的成员变量逐个赋值,这个方式被称为浅拷贝。

深拷贝:当一个类的拷贝构造方法,不仅要复制对象的所有非引用成员变量值,还要为引用类型的成员变量创建新的实例,并且初始化为形式参数实例值。

对于深拷贝和浅拷贝的详细情况,请参考这里:渐析java的浅拷贝和深拷贝

二、模式结构

下图是原型模式的UML结构图:

原型模式主要包含如下三个角色:

       Prototype:抽象原型类。声明克隆自身的接口。 
       ConcretePrototype:具体原型类。实现克隆的具体操作。 
       Client:客户类。让一个原型克隆自身,从而获得一个新的对象。

我们都知道Object是祖宗,所有的Java类都继承至Object,而Object类提供了一个clone()方法,该方法可以将一个java对象复制一份,因此在java中可以直接使用clone()方法来复制一个对象。但是需要实现clone的Java类必须要实现一个接口:Cloneable.该接口表示该类能够复制且具体复制的能力,如果不实现该接口而直接调用clone()方法会抛出CloneNotSupportedException异常。如下:

public class PrototypeDemo implements Cloneable{
  public Object clone(){
    Object object = null;
    try {
      object = super.clone();
    } catch (CloneNotSupportedException exception) {
      System.err.println("Not support cloneable");
    }
    return object;
    }
    ……
}

Java中任何实现了Cloneable接口的类都可以通过调用clone()方法来复制一份自身然后传给调用者。一般而言,clone()方法满足: 
      (1) 对任何的对象x,都有x.clone() !=x,即克隆对象与原对象不是同一个对象。 
      (2) 对任何的对象x,都有x.clone().getClass()==x.getClass(),即克隆对象与原对象的类型一样。 
      (3) 如果对象x的equals()方法定义恰当,那么x.clone().equals(x)应该成立。

三、模式实现

复印简历各位都应该做过吧!这里我们利用原型模式来模拟复印简历。

简历:Resume.java

public class Resume implements Cloneable {
    private String name;
    private String birthday;
    private String sex;
    private String school;
    private String timeArea;
    private String company;

    /**
     * 构造函数:初始化简历赋值姓名
     */
    public Resume(String name){
        this.name = name;
    }

    /**
     * @desc 设定个人基本信息
     * @param birthday 生日
     * @param sex 性别
     * @param school 毕业学校
     * @return void
     */
    public void setPersonInfo(String birthday,String sex,String school){
        this.birthday = birthday;
        this.sex = sex;
        this.school = school;
    }

    /**
     * @desc 设定工作经历
     * @param timeArea 工作年限
     * @param company 所在公司
     * @return void
     */
    public void setWorkExperience(String timeArea,String company){
        this.timeArea = timeArea;
        this.company = company;
    }

    /**
     * 克隆该实例
     */
    public Object clone(){
        Resume resume = null;
        try {
            resume = (Resume) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return resume;
    }

    public void display(){
        System.out.println("姓名:" + name);
        System.out.println("生日:" + birthday + ",性别:" + sex + ",毕业学校:" + school);
        System.out.println("工作年限:" + timeArea + ",公司:" + company);
    }

}

客户端:Client.java

public class Client {
    public static void main(String[] args) {
        //原型A对象
        Resume a = new Resume("小李子");
        a.setPersonInfo("2.16", "男", "XX大学");
        a.setWorkExperience("2012.09.05", "XX科技有限公司");

        //克隆B对象
        Resume b = (Resume) a.clone();

        //输出A和B对象
        System.out.println("----------------A--------------");
        a.display();
        System.out.println("----------------B--------------");
        b.display();

        /*
         * 测试A==B?
         * 对任何的对象x,都有x.clone() !=x,即克隆对象与原对象不是同一个对象
         */
        System.out.print("A==B?");
        System.out.println( a == b);

        /*
         * 对任何的对象x,都有x.clone().getClass()==x.getClass(),即克隆对象与原对象的类型一样。
         */
        System.out.print("A.getClass()==B.getClass()?");
        System.out.println(a.getClass() == b.getClass());
    }
}

运行结果:

四、模式优缺点

优点

      1、如果创建新的对象比较复杂时,可以利用原型模式简化对象的创建过程,同时也能够提高效率。

      2、可以使用深克隆保持对象的状态。

      3、原型模式提供了简化的创建结构。

缺点

1、在实现深克隆的时候可能需要比较复杂的代码。

2、需要为每一个类配备一个克隆方法,而且这个克隆方法需要对类的功能进行通盘考虑,这对全新的类来说不是很难,但对已有的类进行改造时,不一定是件容易的事,必须修改其源代码,违背了“开闭原则”。

五、模式使用场景

1、如果创建新对象成本较大,我们可以利用已有的对象进行复制来获得。

2、如果系统要保存对象的状态,而对象的状态变化很小,或者对象本身占内存不大的时候,也可以使用原型模式配合备忘录模式来应用。相反,如果对象的状态变化很大,或者对象占用的内存很大,那么采用状态模式会比原型模式更好。 
      3、需要避免使用分层次的工厂类来创建分层次的对象,并且类的实例对象只有一个或很少的几个组合状态,通过复制原型对象得到新实例可能比使用构造函数创建一个新实例更加方便。

六、模式总结

      1、原型模式向客户隐藏了创建对象的复杂性。客户只需要知道要创建对象的类型,然后通过请求就可以获得和该对象一模一样的新对象,无须知道具体的创建过程。

      2、克隆分为浅克隆和深克隆两种。

      3、我们虽然可以利用原型模式来获得一个新对象,但有时对象的复制可能会相当的复杂,比如深克隆。

原文地址:https://www.cnblogs.com/shoshana-kong/p/10803309.html

时间: 2024-10-05 05:07:20

设计模式:原型模式(Prototype)的相关文章

谈谈设计模式~原型模式(Prototype)

返回目录 原型模式是创建型模式的一种,其特点在于通过“复制”一个已经存在的实例来返回新的实例(clone),而不是新建(new)实例.被复制的实例就是我们所称的“原型”,这个原型是可定制的. 原型模式多用于创建复杂的或者耗时的实例,因为这种情况下,复制一个已经存在的实例使程序运行更高效:或者创建值相等,只是命名不一样的同类数据. 从原型模式的概念中,我们可以看到,在这个模式里,拷贝是个很重要的概念,即在不创建对象的情况下,返回一个已有对象,这就是拷贝去实现的,在面向对象的编程世界里,拷贝分为浅拷

[工作中的设计模式]原型模式prototype

一.模式解析 提起prototype,最近看多了js相关的内容,第一印象首先是js的原型 var Person=function(name){ this.name=name; } Person.prototype.run=function(){ alert(this.name+" is running"; } 此处的原型是js的特殊定义,在原型上定义的属性和方法所有的类进行共享. 不过设计模式中的原型模式指的是:将已有的对象作为原型,拷贝出一份具有相同属性的新的对象. 模式定义为:原型

java语言实现创建型设计模式—原型模式(Prototype)

一.描述 原型模式是通过一个原型对象来标明要创建的对象的类型,然后用复制这个原型对象的方法来拷贝创建更多的同类型对象.例如我们在程序的动态运行过程中有了一个对象,这个对象中包含了一系列的有效数据,我们此时需要一个和该对象完全相同的新对象,并且在拷贝之后,新旧对象之间没有任何联系,对任何一个对象的更改都不影响另一个对象. 在java中所有类都默认继承自java.lang.Object类,在这个Object类中有一个clone()方法,该方法将返回Object对象的一个拷贝. 我们让需要被拷贝的类实

二十四种设计模式:原型模式(Prototype Pattern)

原型模式(Prototype Pattern) 介绍用原型实例指定创建对象的种类,并且通过拷贝这个原型来创建新的对象. 示例有一个Message实体类,现在要克隆它. MessageModel using System; using System.Collections.Generic; using System.Text; namespace Pattern.Prototype { /// <summary> /// Message实体类 /// </summary> publi

深入浅出设计模式——原型模式(Prototype Pattern)

模式动机在面向对象系统中,使用原型模式来复制一个对象自身,从而克隆出多个与原型对象一模一样的对象.在软件系统中,有些对象的创建过程较为复杂,而且有时候需要频繁创建,原型模式通过给出一个原型对象来指明所要创建的对象的类型,然后用复制这个原型对象的办法创建出更多同类型的对象,这就是原型模式的意图所在. 模式定义原型模式(Prototype Pattern):原型模式是一种对象创建型模式,用原型实例指定创建对象的种类,并且通过复制这些原型创建新的对象.原型模式允许一个对象再创建另外一个可定制的对象,无

10. 星际争霸之php设计模式--原型模式

题记==============================================================================本php设计模式专辑来源于博客(jymoz.com),现在已经访问不了了,这一系列文章是我找了很久才找到完整的,感谢作者jymoz的辛苦付出哦! 本文地址:http://www.cnblogs.com/davidhhuan/p/4248189.html============================================

JAVA 设计模式 原型模式

用途 原型模式 (Prototype) 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象. 原型模式是一种创建型模式. 结构 图-原型模式结构图 Prototype: 声明一个克隆自身的接口.ConcretePrototype: 实现克隆自身的具体操作.Client: 调用 Prototype 来克隆自身,从而创建一个新对象. 应用场景 当要实例化的类是在运行时刻指定时,例如,通过动态装载.为了避免创建一个与产品类层次平行的工厂类层次时.当一个类的实例只能有几个不同状态组合中的一种

炒冷饭系列:设计模式 原型模式

炒冷饭系列:设计模式 原型模式 摘要: 原创出处: http://www.cnblogs.com/Alandre/ 泥沙砖瓦浆木匠 希望转载,保留摘要,谢谢! 亲爱我,孝何难:亲恶我,孝方贤. 一.什么是原型模式 Prototype模式是一种对象创建型模式,它採取复制原型对象的方法来创建对象的实例.使用 Prototype模式创建的实例,具有与原型一样的 数据. 二.原型模式的特点 1. 由原型对象自身创建目标对象.也就是说,对 象创建这一动作发自原型对象本身. 2.目标对象是原型对象的一个克隆

设计模式--原型模式

原型模式 Prototype Pattern 意图:使用原型实例定义/指定被创建对象种类/类型,通过拷贝原型实例创建新对象 应用场景: 1)当某个类指定在运行时实例化 2)减少子类数量 3)降低昂贵类型新对象创建成本 好处或缺点: 1)clone方法可能实现比较困难 2)不适用于含循环引用的类结构 类结构: 参与者:client ,Prototype,ConcretePrototype prototype:定义原型的行为 //关键代码 class Notification implements