设计模式之原型模式

最新推荐文章于 2024-05-07 17:33:22 发布
最新推荐文章于 2024-05-07 17:33:22 发布
阅读量353 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/creasylai19/article/details/47746123
版权

1.定义

使用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象
面向对象语言中，拷贝分为两类：
1. 浅拷贝
对于基础数据类型(如Java中short/int/long/float/double/char/byte/boolean)，直接复制数值，对于引用数据类型，则直接复制引用，修改此引用指向的对象会对原引用对象造成影响
2. 深拷贝
对于基础数据类型，直接复制数值，对于引用数据类型，则拷贝一份引用对象至分配到的新内存中，修改此对象对原引用对象不会有影响

2.UML图

这里写图片描述

Client:客户端用户，提出创建克隆对象的请求
Prototype:原型接口，标识对象是否可以克隆
ConcretePrototye:具体实例，实现了原型接口的类，通过clone()方法可返回自身的一个副本

3.实现

Java中的类都继承自 java.lang.Object。Object 类提供有一个 clone() 方法，可以将一个 Java 对象复制一份。因此在 Java 中可以直接使用 Object 提供的 clone() 方法来实现对象的克隆。
需要注意的是能够实现克隆的 Java 类都必须实现一个标识接口 Cloneable，表示这个 Java 类支持被复制。如果一个类没有实现这个接口但是调用了 clone() 方法，Java 编译器将抛出一个 CloneNotSupportedException 异常。
以下以持有手机的个人的克隆为示例
1. 简单形式
个人所持有的手机Phone类

package com.creasy.testjava;

public class Phone{

    private String phone_brand;
    private String phone_number;

    public Phone() {
    }

    public void setBrandAndNumber(String phone_brand, String phone_number) {
        this.phone_brand = phone_brand;
        this.phone_number = phone_number;
    }

    public void Display() {
        System.out.print("phone_brand:" + phone_brand + " and phone_number:" + phone_number);
    }

}

个人类Person

package com.creasy.testjava;

public class Person implements Cloneable {

    private String name;
    private int age;
    private Phone phone;

    public Person() {
    }

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

    public void setNameAndAge(String name, int age, Phone phone) {
        this.name = name;
        this.age = age;
        this.phone = phone;
    }

    public void Display() {
        System.out.print("name:" + name + " and age:" + age + " ");
        if (null == phone) {
            System.out.println("has no phone");
        } else {
            phone.Display();
        }
        System.out.println();
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Phone getPhone() {
        return phone;
    }

}

客户端调用：

package com.creasy.testjava;

/**
 * @author laicreasy
 *
 */
public class TestBaseJavaFunction {

    public static void main(String[] args) {
        try {
            Person a = new Person();
            Phone phone = new Phone();
            phone.setBrandAndNumber("iPhone", "1234567890");
            a.setNameAndAge("xiaoli", 18, phone);
            Person b = (Person) a.clone();
            a.Display();
            phone.setBrandAndNumber("Android", "0987654321");
            a.Display();
            b.Display();
            System.out.println(a.getPhone() == b.getPhone());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }

}

输出结果：

name:xiaoli and age:18 phone_brand:iPhone and phone_number:1234567890
name:xiaoli and age:18 phone_brand:Android and phone_number:0987654321
name:xiaoli and age:18 phone_brand:Android and phone_number:0987654321
true

由结果可以看出，Person中Phone的克隆只是简单的复制了引用给到新对象。如果Phone类改成

package com.creasy.testjava;

public class Phone implements Cloneable{

    private String phone_brand;
    private String phone_number;

    public Phone() {
    }

    public void setBrandAndNumber(String phone_brand, String phone_number) {
        this.phone_brand = phone_brand;
        this.phone_number = phone_number;
    }

    public void Display() {
        System.out.print("phone_brand:" + phone_brand + " and phone_number:" + phone_number);
    }

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

而Person类中的clone方法改成

@Override
    protected Object clone() throws CloneNotSupportedException {
        Person p = (Person)super.clone();
        p.phone = (Phone)this.phone.clone();
        return p;
    }

再次运行，得到结果

name:xiaoli and age:18 phone_brand:iPhone and phone_number:1234567890
name:xiaoli and age:18 phone_brand:Android and phone_number:0987654321
name:xiaoli and age:18 phone_brand:iPhone and phone_number:1234567890
false

由结果可以看到，此时则是深层复制，a和b中的phone指向的是不同的对象的
2. 实现Serializable形式
序列化的过程就是把数据从内存中写入流中，反序列化则是从流中把数据再写入新内存中，通过序列化和反序列化则可以实现对象的深层复制
Phone类

package com.creasy.testjava;

import java.io.Serializable;

public class Phone implements Serializable{

    private static final long serialVersionUID = 8785807031027660303L;

    private String phone_brand;
    private String phone_number;

    public Phone() {
    }

    public void setBrandAndNumber(String phone_brand, String phone_number) {
        this.phone_brand = phone_brand;
        this.phone_number = phone_number;
    }

    public void Display() {
        System.out.print("phone_brand:" + phone_brand + " and phone_number:" + phone_number);
    }

}

Person类：

package com.creasy.testjava;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Person implements Serializable {

    /**
     * 
     */
    private static final long serialVersionUID = 5767629194216311414L;

    private String name;
    private int age;
    private Phone phone;

    public Person() {
    }

    public Person deepClone() throws IOException, ClassNotFoundException  {
        //将对象写入流中
        ByteArrayOutputStream bao=new  ByteArrayOutputStream();
        ObjectOutputStream oos=new  ObjectOutputStream(bao);
        oos.writeObject(this);
        //将对象从流中取出
        ByteArrayInputStream bis=new  ByteArrayInputStream(bao.toByteArray());
        ObjectInputStream ois=new  ObjectInputStream(bis);
        return  (Person)ois.readObject();
    }

    public void setNameAndAge(String name, int age, Phone phone) {
        this.name = name;
        this.age = age;
        this.phone = phone;
    }

    public void Display() {
        System.out.print("name:" + name + " and age:" + age + " ");
        if (null == phone) {
            System.out.println("has no phone");
        } else {
            phone.Display();
        }
        System.out.println();
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Phone getPhone() {
        return phone;
    }

}

客户端调用

package com.creasy.testjava;

/**
 * @author laicreasy
 *
 */
public class TestBaseJavaFunction {

    public static void main(String[] args) {
        try {
            Person a = new Person();
            Phone phone = new Phone();
            phone.setBrandAndNumber("iPhone", "1234567890");
            a.setNameAndAge("xiaoli", 18, phone);
            Person b = (Person) a.deepClone();
            a.Display();
            phone.setBrandAndNumber("Android", "0987654321");
            a.Display();
            b.Display();
            System.out.println(a.getPhone() == b.getPhone());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

运行结果

name:xiaoli and age:18 phone_brand:iPhone and phone_number:1234567890
name:xiaoli and age:18 phone_brand:Android and phone_number:0987654321
name:xiaoli and age:18 phone_brand:iPhone and phone_number:1234567890
false

由结果可以看出，对应a和对象b是不同的对象，并且他们各自持有不同的phone对象
通过序列化及反序列化进行深层复制的前提是对象以及对象内部所有引用到的对象都是可序列化的，否则，需要声明不可序列化的对象成transient，从而将之排除在复制过程之外。关于transient关键字的描述，可参考：transient

4.Android或者Java中的使用

Android中，存储Integer和Object的键值对类SparseArray实现了Cloneable，直接看其clone源码，如下：

    private int[] mKeys;
    private Object[] mValues;

    @Override
    @SuppressWarnings("unchecked")
    public SparseArray<E> clone() {
        SparseArray<E> clone = null;
        try {
            clone = (SparseArray<E>) super.clone();
            clone.mKeys = mKeys.clone();
            clone.mValues = mValues.clone();
        } catch (CloneNotSupportedException cnse) {
            /* ignore */
        }
        return clone;
    }

使用SparseArray测试，代码及结果如下

public void testSparseArray() {
        SparseArray<Phone> mSparseArray = new SparseArray<Phone>();
        Phone phone1 = new Phone();
        phone1.setBrandAndNumber("SANXING", "123456789");
        Phone phone2 = new Phone();
        phone2.setBrandAndNumber("APPLE", "123456789");
        mSparseArray.put(0, phone1);
        mSparseArray.put(1, phone2);
        //mSparseArray1
        for( int i=0; i < mSparseArray.size(); i++ ) {
            Phone p = mSparseArray.get(i);
            System.out.println("phone_brand:" + p.getPhone_brand() + " and phone_number:" + p.getPhone_number());
        }
        SparseArray<Phone> mSparseArray2 = mSparseArray.clone();
        for( int i=0; i < mSparseArray2.size(); i++ ) {
            Phone p = mSparseArray.get(i);
            p.setBrandAndNumber(p.getPhone_brand() + "2", p.getPhone_number() + "2");
        }
        //mSparseArray2
        for( int i=0; i < mSparseArray2.size(); i++ ) {
            Phone p = mSparseArray2.get(i);
            System.out.println("phone_brand:" + p.getPhone_brand() + " and phone_number:" + p.getPhone_number());
        }
        //mSparseArray1
        for( int i=0; i < mSparseArray.size(); i++ ) {
            Phone p = mSparseArray.get(i);
            System.out.println("phone_brand:" + p.getPhone_brand() + " and phone_number:" + p.getPhone_number());
        }
        //mSparseArray2
        for( int i=0; i < mSparseArray2.size(); i++ ) {
            Phone p = mSparseArray2.get(i);
            System.out.println("phone_brand:" + p.getPhone_brand() + " and phone_number:" + p.getPhone_number());
        }
        System.out.println(mSparseArray == mSparseArray2);
    }

结果
这里写图片描述
由上，可见SparseArray中clone方法执行的是浅层复制功能（实际上SparseArray中存储的Object为数组，而数组的clone执行的是浅层复制功能）

5.使用场景

(1) 创建新对象成本较大（如初始化需要占用较长的时间，占用太多的 CPU 资源或网络资源），新的对象可以通过原型模式对已有对象进行复制来获得
(2)当一个类引用不支持序列化的间接对象，或者引用含有循环结构的时候，不适合使用原型模式

参考博客：
http://wiki.jikexueyuan.com/project/design-pattern-creation/protorype-four.html
http://blog.csdn.net/bboyfeiyu/article/details/38398475
http://www.cnblogs.com/java-my-life/archive/2012/04/11/2439387.html

creasylai19
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式之原型模式.docx
09-28
设计模式
java设计模式之原型模式
m0_47944994的博客
11-16 3667
java设计模式之原型模式
23种设计模式之原型模式
zt的博客
03-18 3116
文章目录原型模式浅拷贝 原型模式 原型模式是一种创建型设计模式,Prototype模式允许一个对象再创建另外一个可定制的对象,根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。原型模式包含以下角色： 抽象原型类：规定了具体原型对象必须实现的clone()方法 具体原型类：实现了抽象原型类的clone()方法,它是可以被复制的对象 访问类：使用具体原型类中的clone()方法来复制新对象 原型模式的克隆分为浅
C#设计模式之原型模式
BraveRunTo的博客
07-10 882
原型模式 文章目录原型模式模式分类模式产生的原因模式的灵感来源模式类图深克隆和浅克隆浅克隆深克隆经典代码实现原型模式通用实现：原型模式C#实现：原型模式总结原型模式的优点：原型模式的缺点： 本篇博客将介绍原型模式，原型模式是一种比较特殊的模式，它通过复制一个已经存在的对象来得到一个全新的对象，原则上我们改变新对象的内容源对象是不会受影响的。学习原型模式我们就需要明白程序中的两种克隆类型：深克隆和浅克隆。 模式分类 创建型设计模式。 模式产生的原因 当我们需要创建一大堆成本开销比较大的对象但是他们都是相似或者
设计模式之原型模式(C++)
翟天保的博客
03-08 2万+
介绍设计模式之原型模式
JAVA设计模式之单例模式
热门推荐
一个本科小生的奋斗史
04-16 98万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
设计模式23模式介绍
学Java，找哪吒
01-18 13万+
设计模式精品专栏。
Java设计模式之原型模式
Aslixzhou
06-16 2588
>>Java设计模式之原型模式的简单使用~
Java常见设计模式总结
张维鹏的博客
09-18 18万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
设计模式之原型模式的理解
来自上海的这位朋友
08-07 966
设计模式之原型模式的理解
C++设计模式之原型模式
09-04
主要介绍了C++设计模式之原型模式,本文讲解了什么是原型模式、为什么要使用原型模式、代码实例等内容,需要的朋友可以参考下
设计模式：桥接模式
玉汝于成
05-06 819
接模式是一种对象结构型模式，它将抽象部分与它的实现部分分离，使它们都可以独立地变化。这种分离允许抽象和实现部分独立地扩展，而不会相互影响。桥接模式基于类的最小设计原则，通过封装、聚合及继承等行为让不同的类承担不同的职责。
QT设计模式：外观模式
最新发布
buhuiCyvyan的博客
05-07 175
外观模式（Facade Pattern）是一种设计模式，它提供了一个统一的接口，用于访问子系统中的一群接口，从而简化了客户端与子系统之间的交互，这种方式隐藏了子系统的复杂性，使客户端更容易使用子系统。
【学习vue 3.x】(一)基础内容
m0_74187147的博客
04-30 1721
Vue.js是一套构建用户界面的渐进式框架，采用自底向上增量开发的设计，核心库只关注视图层。另一方面，Vue完全有能力驱动采用单文件组件和Vue生态系统支持的库开发的复杂单页应用。 Vue是一个框架，也是一个生态。可以用不同的方式使用Vue： 无需构建步骤，渐进式增强静态的HTML； 在任何页面中作为Web Components嵌入； 单页应用 (SPA)； 全栈/服务端渲染 (SSR)； Jamstack/静态站点生成 (SSG)； 开发桌面端、移动端、WebGL，甚至是命令行终端中的界面。
设计模式: 工厂模式
m0_59925573的博客
05-02 681
定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。主要解决接口选择的问题。我们明确地计划不同条件下创建不同实例时。让其子类实现工厂接口，返回的也是一个抽象的产品。创建过程在其子类执行。1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。2、在 Hibernate 中，如果需要更换数据库，工厂模式同样发挥了作用。只需简单地更改方言（Dialect）和数据库驱动（Driver），就能够实现对不同数据库的切换。
Python如何实现抽象工厂模式
一点
04-30 1302
在软件工程中，抽象工厂模式（Abstract Factory Pattern）是一种设计模式，用于在运行时创建一组相关或相互依赖的对象，而不需要指定它们的具体类。这种模式非常适合用于管理系统中对象的创建，同时保持这些对象之间的一致性和隔离性。抽象工厂模式涉及以下几个关键概念：抽象工厂（Abstract Factory）：提供一个创建一系列相关或依赖对象的接口，而不需要指定具体类。具体工厂（Concrete Factory）：实现抽象工厂接口，生产具体的产品对象。
设计模式之MVC模式
Rcain_R的博客
05-02 1249
MVC（Model-View-Controller）模式是一种软件设计模式，广泛应用于构建用户界面的软件架构中，特别是在Web应用程序开发中。
介绍一下C++设计模式之原型模式
07-23
原型模式（Prototype Pattern）是一种创建型设计模式，它允许通过复制现有对象来创建新对象，而无需通过显式的实例化过程。原型模式通过克隆（clone）已有对象来创建新对象，从而避免了使用传统的构造函数创建对象的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值