设计模式之原型模式

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

原型模式概述

定义

原型模式定义如下：

Specify the kinds of objects to create using a prototypical instance,and create new objects by copying this prototype.（用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。）

原型模式通用类图：
在这里插入图片描述原型模式的核心是一个clone方法，通过该方法进行对象的拷贝，Java提供了一个Cloneable接口来标示这个对象是可拷贝的

具体案例

先看一个需求：
有一个通用的产品，有许多成员变量，除了baseInfo其余的都一样，代码如下：

package com.dq.designpattern.prototype.shallowCopy;

public class Product {

    private String part1;
    private Integer part2;
    //...省略了其它成员变量
    private BaseInfo baseInfo;

    public String getPart1() {
        return part1;
    }

    public Product(String part1, Integer part2, BaseInfo baseInfo) {
        this.part1 = part1;
        this.part2 = part2;
        this.baseInfo = baseInfo;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public Integer getPart2() {
        return part2;
    }

    public void setPart2(Integer part2) {
        this.part2 = part2;
    }

    public BaseInfo getBaseInfo() {
        return baseInfo;
    }

    public void setBaseInfo(BaseInfo baseInfo) {
        this.baseInfo = baseInfo;
    }

    @Override
    public String toString() {
        return super.hashCode()+" ] Product{" +
                "part1='" + part1 + '\'' +
                ", part2=" + part2 +
                ", baseInfo=" + baseInfo +
                '}';
    }
}

package com.dq.designpattern.prototype.shallowCopy;

public class BaseInfo {
    private String companyName;

    public BaseInfo(String companyName) {
        this.companyName = companyName;
    }

    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

    @Override
    public String toString() {
        return super.hashCode()+" ] BaseInfo{" +
                "companyName='" + companyName + '\'' +
                '}';
    }
}

我们在new这个对象时，每次都要进行大量的初始化加载工作，但是每一个对象除了baseInfo，别的信息都一样，这时候我们可以使用原型模式，每次不要new出对象，而是用第一个new出的对象进行不断克隆，克隆出来的对象再设置其baseInfo即可。

优点

  • 性能优良

    原型模式是在内存二进制流的拷贝，要比直接new一个对象性能好很多，特别是要在一个循环体内产生大量的对象时，原型模式可以更好地体现其优点。

  • 逃避构造函数的约束

    这既是它的优点也是缺点，直接在内存中拷贝，构造函数是不会执行的。优点就是减少了约束，缺点也是减少了约束，需要大家在实际应用时考虑。

使用场景

  • 资源优化场景

    类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。

  • 性能和安全要求的场景

    通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。

  • 一个对象多个修改者的场景

    一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。

注意事项

  • 构造函数不会被执行

    一个实现了Cloneable并重写了clone方法的类A，有一个无参构造或有参构造B，通过new关键字产生了一个对象S，再然后通过S.clone()方式产生了一个新的对象T，那么在对象拷贝时构造函数B是不会被执行的。

  • clone与final

    要使用clone方法，类的成员变量上不要增加final关键字。

浅拷贝

浅拷贝代码如下：

package com.dq.designpattern.prototype.shallowCopy;

public class Product implements Cloneable{

    private String part1;
    private Integer part2;
    //...省略了其它成员变量
    private BaseInfo baseInfo;

    public String getPart1() {
        return part1;
    }

    public Product(String part1, Integer part2, BaseInfo baseInfo) {
        this.part1 = part1;
        this.part2 = part2;
        this.baseInfo = baseInfo;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public Integer getPart2() {
        return part2;
    }

    public void setPart2(Integer part2) {
        this.part2 = part2;
    }

    public BaseInfo getBaseInfo() {
        return baseInfo;
    }

    public void setBaseInfo(BaseInfo baseInfo) {
        this.baseInfo = baseInfo;
    }

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

    @Override
    public String toString() {
        return super.hashCode()+" ] Product{" +
                "part1='" + part1 + '\'' +
                ", part2=" + part2 +
                ", baseInfo=" + baseInfo +
                '}';
    }
}

我们来看测试代码：

package com.dq.designpattern.prototype.shallowCopy;

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        BaseInfo baseInfo = new BaseInfo("dddd");
        Product product = new Product("part1",2,baseInfo);
        Product clone = product.clone();
        System.out.println("原始对象："+product);
        System.out.println("克隆对象："+clone);
        product.setPart1("new part1");
        product.getBaseInfo().setCompanyName("qqqq");
        System.out.println("原始对象："+product);
        System.out.println("克隆对象："+clone);

    }
}

运行结果：
在这里插入图片描述通过两个对象的哈希码可以知道，克隆对象和原始对象不是一个对象，当修改原始对象的part1和baseInfo时，克隆对象的part1没有变化，但它的baseInfo却跟着变化了。

原因：

Java做了一个偷懒的拷贝动作，Object类提供的方法clone只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址，这种拷贝就叫做浅拷贝。确实是非常浅，两个对象共享了一个私有变量，你改我改大家都能改，是一种非常不安全的方式，

深拷贝

进行深拷贝的时候，Product和BaseInfo两个类都要实现Cloneable接口并重写clone()方法。

package com.dq.designpattern.prototype.deepCopy;

public class BaseInfo implements Cloneable{
    private String companyName;

    public BaseInfo(String companyName) {
        this.companyName = companyName;
    }

    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

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

    @Override
    public String toString() {
        return super.hashCode()+" ] BaseInfo{" +
                "companyName='" + companyName + '\'' +
                '}';
    }
}

package com.dq.designpattern.prototype.deepCopy;

public class Product implements Cloneable{

    private String part1;
    private Integer part2;
    //...省略了其它成员变量
    private BaseInfo baseInfo;

    public String getPart1() {
        return part1;
    }

    public Product(String part1, Integer part2, BaseInfo baseInfo) {
        this.part1 = part1;
        this.part2 = part2;
        this.baseInfo = baseInfo;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public Integer getPart2() {
        return part2;
    }

    public void setPart2(Integer part2) {
        this.part2 = part2;
    }

    public BaseInfo getBaseInfo() {
        return baseInfo;
    }

    public void setBaseInfo(BaseInfo baseInfo) {
        this.baseInfo = baseInfo;
    }

    @Override
    protected Product clone() throws CloneNotSupportedException {
        //return (Product)super.clone();
        Product product = (Product) super.clone();
        BaseInfo baseInfo = this.baseInfo.clone();
        product.setBaseInfo(baseInfo);
        return product;
    }

    @Override
    public String toString() {
        return super.hashCode()+" ] Product{" +
                "part1='" + part1 + '\'' +
                ", part2=" + part2 +
                ", baseInfo=" + baseInfo +
                '}';
    }
}

再看测试代码：

package com.dq.designpattern.prototype.deepCopy;

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        BaseInfo baseInfo = new BaseInfo("dddd");
        Product product = new Product("part1",2,baseInfo);
        Product clone = product.clone();
        System.out.println("原始对象："+product);
        System.out.println("克隆对象："+clone);
        product.setPart1("new part1");
        product.getBaseInfo().setCompanyName("qqqq");
        System.out.println("原始对象："+product);
        System.out.println("克隆对象："+clone);

    }
}

结果：
在这里插入图片描述
从结果看出：修改原始对象后，克隆对象的数据没有改变，说明两者完全独立，实现了深拷贝。

序列化实现深拷贝

实现Serializable接口，利用IO流

package com.dq.designpattern.prototype.serializable;

import java.io.Serializable;

public class BaseInfo implements Cloneable, Serializable {
    private String companyName;

    public BaseInfo(String companyName) {
        this.companyName = companyName;
    }

    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

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

    @Override
    public String toString() {
        return super.hashCode()+" ] BaseInfo{" +
                "companyName='" + companyName + '\'' +
                '}';
    }
}

package com.dq.designpattern.prototype.serializable;

import com.dq.designpattern.builder.BianzhongBuilder.Person;

import java.io.*;

public class Product implements Cloneable, Serializable {

    private String part1;
    private Integer part2;
    //...省略了其它成员变量
    private BaseInfo baseInfo;

    public String getPart1() {
        return part1;
    }

    public Product(String part1, Integer part2, BaseInfo baseInfo) {
        this.part1 = part1;
        this.part2 = part2;
        this.baseInfo = baseInfo;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public Integer getPart2() {
        return part2;
    }

    public void setPart2(Integer part2) {
        this.part2 = part2;
    }

    public BaseInfo getBaseInfo() {
        return baseInfo;
    }

    public void setBaseInfo(BaseInfo baseInfo) {
        this.baseInfo = baseInfo;
    }

    @Override
    protected Product clone() {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        try (ObjectOutputStream oos = new ObjectOutputStream(byteArrayOutputStream);){
            oos.writeObject(this);
        } catch (IOException e) {
            e.printStackTrace();
        }
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
        try (ObjectInputStream ois = new ObjectInputStream(byteArrayInputStream)){
            Product product = (Product)ois.readObject();
            return product;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public String toString() {
        return super.hashCode()+" ] Product{" +
                "part1='" + part1 + '\'' +
                ", part2=" + part2 +
                ", baseInfo=" + baseInfo +
                '}';
    }
}

package com.dq.designpattern.prototype.serializable;

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        BaseInfo baseInfo = new BaseInfo("dddd");
        Product product = new Product("part1",2,baseInfo);
        Product clone = product.clone();
        System.out.println("原始对象："+product);
        System.out.println("克隆对象："+clone);
        product.setPart1("new part1");
        product.getBaseInfo().setCompanyName("qqqq");
        System.out.println("原始对象："+product);
        System.out.println("克隆对象："+clone);

    }
}

在这里插入图片描述

丁俏
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++设计模式之原型模式
09-04
原型模式是一种创建型设计模式，它提供了一种创建对象的新方式，通过复制现有的对象来创建新对象，而不是通过传统的构造函数。在C++中，原型模式通常涉及到对象的深拷贝或浅拷贝，用于避免复杂的初始化过程或者当...
设计模式之：原型模式
08-21 320
虚函数特殊的一个情况就是基类和子类的返回类型可以分别是它们自身的类型! #include using namespace std; //接口 class Product { public: Product(){} virtual ~Product(){} virtual void fun() { cout } virtual Product *
Java设计模式--原型模式
weixin_44808225的博客
05-05 94
Java设计模式–原型模式 定义 指原型实例指定创建对象的种类，并且通过拷贝这些原型创建的新对象 实现 public class PortotypeTest { public static void main(String[] args) throws CloneNotSupportedException { // TODO Auto-generated method stub...
java设计模式之原型模式
m0_47944994的博客
11-16 3794
java设计模式之原型模式
23种设计模式之原型模式
zt的博客
03-18 3176
文章目录原型模式浅拷贝 原型模式 原型模式是一种创建型设计模式,Prototype模式允许一个对象再创建另外一个可定制的对象,根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。原型模式包含以下角色： 抽象原型类：规定了具体原型对象必须实现的clone()方法 具体原型类：实现了抽象原型类的clone()方法,它是可以被复制的对象 访问类：使用具体原型类中的clone()方法来复制新对象 原型模式的克隆分为浅
C#设计模式之原型模式
BraveRunTo的博客
07-10 932
原型模式 文章目录原型模式模式分类模式产生的原因模式的灵感来源模式类图深克隆和浅克隆浅克隆深克隆经典代码实现原型模式通用实现：原型模式C#实现：原型模式总结原型模式的优点：原型模式的缺点： 本篇博客将介绍原型模式，原型模式是一种比较特殊的模式，它通过复制一个已经存在的对象来得到一个全新的对象，原则上我们改变新对象的内容源对象是不会受影响的。学习原型模式我们就需要明白程序中的两种克隆类型：深克隆和浅克隆。 模式分类 创建型设计模式。 模式产生的原因 当我们需要创建一大堆成本开销比较大的对象但是他们都是相似或者
C++ 设计模式之原型模式
K1_uestc的博客
01-09 1126
实现原型模式需要给【原型对象】声明⼀个克隆⽅法，执⾏该⽅法会创建⼀个当前类的新对象，并将原始对象中的成员变量复制到新⽣成的对象中，⽽不必实例化。如果⼀个对象的创建过程⽐较复杂时（⽐如需要经过⼀系列的计算和资源消耗），那每次创建该对象都需要消耗资源，⽽通过原型模式就可以复制现有的⼀个对象来迅速创建/克隆⼀个新对象，、并且可以通过克隆避免重复初始化⼯作的场景时可以考虑使⽤原型模式，在克隆对象的时候还可以动态地添加或删除原型对象的属性，创造出相似但不完全相同的对象，提⾼了灵活性。，⽽不是从头开始创建。
设计模式之原型模式(C++)
翟天保的博客
03-08 2万+
介绍设计模式之原型模式
JAVA设计模式之单例模式
热门推荐
一个本科小生的奋斗史
04-16 99万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
JAVA设计模式之原型模式详解
励志成为一名优秀的全能型软件开发工程师。
02-05 3242
定义: 原型模式(Prototype Design Pattern)用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。西游记中的孙悟空 拔毛变小猴,孙悟空这种根据自己的形状复制出多个身外化身的技巧,在面向对象软件设计领域被称为原型模式.孙悟空就是原型对象.原型模式主要解决的问题。
设计模式23模式介绍
学Java，找哪吒
01-18 13万+
设计模式精品专栏。
设计模式之原型模式.docx
09-28
【设计模式之原型模式】 设计模式是软件工程中的一种最佳实践，是对在特定上下文中反复出现的软件设计问题的解决方案。原型模式属于对象创建型模式，它的主要思想是通过复制已有对象来创建新对象，降低了类的实例化...
《C++20设计模式》命令模式思考
Ten_years_star的博客
07-07 730
哎！只要是书上写的和经典设计模式不同，我就会很伤脑筋。😩 **命令模式到底是干什么的？** 答：命令的发送者和接收者完全解耦
常用设计模式
u010992421的专栏
07-12 586
设计模式是在软件开发中经过验证的、用于解决常见问题的最佳实践。它们可以帮助开发者设计出更加灵活、可维护和可扩展的软件系统。这些设计模式通常被分为三大类：创建型模式、结构型模式和行为型模式。
GPT带我学-设计模式13-策略模式
qq_37398465的博客
07-09 467
策略模式。
Java学习笔记整理: 关于设计模式解析和设计原则 2024/7/10；
gzx233的博客
07-10 564
Java设计模式设计原则
设计模式探索：适配器模式
搬砖的小熊猫的博客
07-09 1139
将一个类的接口转换为客户期望的另一个接口，适配器可以让不兼容的两个类一起协同工作。适配器模式的主要作用是把原本不兼容的接口，通过适配修改做到统一，使得用户方便使用。比如，万能充电器和多接口数据线都是为了适配各种不同的接口。为什么要转换接口？原接口和目标接口都已经存在，不易修改接口代码。抽象接口希望复用已有组件的逻辑。优点：解耦合: 适配器模式允许两个没有直接关联的类协同工作，降低了它们之间的耦合度。提高复用性: 通过适配器，可以重用现有的类，而不需要修改它们的代码。统一接口。
java设计模式之:策略模式+工厂模式整合案例实战(一)
最新发布
royal1235的博客
07-12 254
然后通过策略工厂来获取具体的策略类：(由于只有三个策略类，所以通过注入的方式对channel进行判断)案例1：项目中对系统中的客户和销售进行事件通知(短信、邮件、钉钉)到此该版本的策略模式+工厂模式就结束了，欢迎点评和指出不足之处。首先要有通知的策略接口，接口里面要有一个方法就是通知的方法。有了接口那必然有实现类，三个实现类短信、邮件、钉钉。该案例是针对策略类比较少的情况。下一篇会讲解策略类比较多的案例。本文介绍项目中常用的。
介绍一下C++设计模式之原型模式
07-23
原型模式（Prototype Pattern）是一种创建型设计模式，它允许通过复制现有对象来创建新对象，而无需通过显式的实例化过程。原型模式通过克隆（clone）已有对象来创建新对象，从而避免了使用传统的构造函数创建对象的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值