当前位置： 首页 > news >正文

【设计模式】 原型模式

news 2025/9/8 7:16:21

系列文章目录

文章目录

  • 系列文章目录
    • 简历代码初步实现
    • 原型模式
    • 简历代码的原型实现
    • 浅复制与深复制
  • 总结

在这里插入图片描述

在本篇文章里，我们设定为制造简历，需求是要求有一个简历类，必须要有姓名，可以设置性别和年龄，可以设置工作经历，最终需求三分简历。

简历代码初步实现


//简历类
class Resume{private String name;private String sex;private String age;private String timeArea;private String company;public Resume(String name){this.name = name;}public void setPersonalInfo(String sex,String age){this.sex = sex;this.age = age;}public void setWorkExperience(String timeArea,String company){this.company = company;this.timeArea = timeArea;}public void display(){System.out.println(this.name + " " + this.sex + " " + this.age);System.out.println("工作经历 " + this.timeArea + " " + this.company);}}//客户端public static void main(String[] args) {Resume resume1 = new Resume("小张");resume1.setPersonalInfo("男" , "XX公司");resume1.setWorkExperience("2024-2025", "XX公司");Resume resume2 = new Resume("小张");resume2.setPersonalInfo("男","XX公司");resume2.setWorkExperience("2024-2025" ,"XX公司");Resume resume3 = new Resume("小张");resume3.setPersonalInfo("男", "XX公司");resume3.setWorkExperience("2024-2025","XX公司");resume1.display();resume2.display();resume3.display();}

这里从我们所写的代码可以发现，三份简历需要三次实例化。这样的客户端会很麻烦，如果要20份简历的话，那我们就需要进行二十次实例化。如果我们有一处写错了，那么要修改也需要修改二十次。这里我们有另外一种写法。

public static void main(String[] args) {Resume resume1 = new Resume("小张");resume1.setPersonalInfo("男" , "XX公司");resume1.setWorkExperience("2024-2025", "XX公司");Resume resume2 = resume1;Resume resume3 = resume1;resume1.display();resume2.display();resume3.display();}

这里其实是传引用，而不是传值，这样做就如同实在resume2的纸张和resume3的纸张上写着简历在resume1处一样，没有实际内容

我们知道有克隆Clone的方法。原型模式就是主要使用的这个方法。

原型模式

在介绍克隆前，我们要先提一个设计模式。

原型模式 ： 用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。

原型模式其实就是从一个对象在创建到另外一个可定制的对象，而且不需要知道任何创建的细节。 ，我们来看基本的原型模式代码。

 //原型类abstract class Prototype implements Cloneable{private String id;public Prototype(String id){this.id = id;}public String getID(){return this.id;}public Object clone(){Object object = null;try{object = super.clone();}catch(CloneNotSupportedException exception){System.out.println("Clone 异常");}return object;}}//具体原型类class ConcretePrototype extends Prototype{public ConcretePrototype(String id) {super(id);}}//客户端代码public static void main(String[] args) {ConcretePrototype p1 = new ConcretePrototype("编号123456");System.out.println("原ID " + p1.getID());ConcretePrototype c1 = (ConcretePrototype) p1.clone();System.out.println("克隆ID" + c1.getID());}

这样的话可以不用实例化ConcretePrototype，直接克隆就可以，但是对于Java而言，那个原型的抽象类Protype是用不着的，因为克隆实在是太常用了，所以Java提供了Cloneable接口， ，其中就是唯一的一个方法clone(); 这样你就只需要实现这个接口就可以完成原型模式了。

现在我们来修改原来的简历模型。

简历代码的原型实现

第二版代码：

//简历
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;}public void setPersonalInfo(String sex,String age){this.sex = sex;this.age = age;}public void setWorkExperience(String timeArea,String company){this.company = company;this.timeArea = timeArea;}public void display(){System.out.println(this.name + " " + this.sex + " " + this.age);System.out.println("工作经历 " + this.timeArea + " " + this.company);}public Resume clone(){Resume object = null;try{object = (Resume) super.clone();}catch(CloneNotSupportedException exception){System.out.println("Clone异常");}return object;}}//客户端public static void main(String[] args) {Resume resume1 = new Resume("小张");resume1.setPersonalInfo("男" , "XX公司");resume1.setWorkExperience("2024-2025", "XX公司");//调用clone()方法就可以实现新简历的生成Resume resume2 = resume1.clone();//可以修改新简历的细节resume2.setWorkExperience("2023-2025","YY集团");Resume resume3 =resume1.clone();resume3.setPersonalInfo("男" ,"24");resume1.display();resume2.display();resume3.display();}

这样的话，客户端代码就清晰多了，而且要想修改某份简历，我们只需要对这份简历做一定的修改就可以了，不会影响其他简历。

之前的话，每new一次都需要执行一次构造函数，如果构造函数执行时间很长，多次执行就太低效了，一般在初始化的信息不发生变化的情况下，克隆是最好的办法。这既隐藏了对象创建的细节，又对性能是大大的提高。 它 不用重新初始化对象，
而是动态的获得对象运行时的状态。

浅复制与深复制

那么如果我们需要修改需求呢，因为简历对象里的数据都是String型的，而String是一种拥有值类型特点的特殊引用类型，super.clone()方法是这样，如果字段是值类型的，则对该字段执行逐位复制，如果字段是引用类型，则复制引用不复制引用的对象，因此，原始对象及副本引用同一个对象。 就是说如果你的“简历”类当中有对象引用，那么引用的对象数据是不会被克隆过来的。

下面我们用代码举例，现在简历类中有一个‘设置工作经历’的方法，在设计时一般会有一个；工作经历类，当中有‘时间区间’和‘公司名称’等属性，‘简历’类直接调用这个对象即可，代码如下：

  //简历类class Resume implements Cloneable{private String name;private String sex;private String age;private WorkExperience work;public Resume(String name){this.name = name;this.work = new WorkExperience();}public void setPersonalInfo(String sex,String age){this.sex = sex;this.age = age;}public void setWorkExperience(String timeArea,String company){this.work.setTimeArea(timeArea);this.work.setCompany(company);}public void display(){System.out.println(this.name + " " + this.sex + " " + this.age);System.out.println("工作经历 " + this.work.getTimeArea() + " " + this.work.getCompany());}public Resume clone(){Resume object = null;try{object = (Resume) super.clone();}catch(CloneNotSupportedException exception){System.out.println("Clone异常");}return object;}}class WorkExperience{private String timeArea;public String getTimeArea() {return timeArea;}public void setTimeArea(String timeArea) {this.timeArea = timeArea;}private String company;public String getCompany() {return company;}public void setCompany(String company) {this.company = company;}}//客户端public static void main(String[] args) {Resume resume1 = new Resume("小张");resume1.setPersonalInfo("男" , "24");resume1.setWorkExperience("2024-2025", "XX公司");//调用clone()方法就可以实现新简历的生成Resume resume2 = resume1.clone();//可以修改新简历的细节resume2.setWorkExperience("2023-2025","YY集团");Resume resume3 =resume1.clone();resume3.setPersonalInfo("男" ,"26");resume3.setWorkExperience("2025","ZZ公司");resume1.display();resume2.display();resume3.display();}

这里我们期望的展示结果为

小张 男 24
工作经历 2024-2025 XX公司
小张 男 24
工作经历 2023-2025 YY公司
小张 男 26
工作经历 2025 ZZ公司

但是我们的事实结果是：

小张 男 24
工作经历 2025 ZZ公司
小张 男 24
工作经历 2025 ZZ公司
小张 男 26
工作经历 2025 ZZ公司

这里主要是因为它是浅表复制，所以对于值类型，没什么问题，但是对引用类型，就只是复制了一个引用，对引用的对象还是指向了原来的对象，所以就会出现我给resume1、resume2、resume3三个引用设置‘工作经历’，但却看到三个引用最后都是最后一次设置，因为三个引用都指向了一个对象。

以上这种情况就叫做浅复制，被复制的对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。 但是我们可能更需要这样的一种需求，把要复制的对象所引用的对象都复制一遍。 比如刚才那个例子，我们就希望是resume1，resume2，resume3三个应用的对象是不同的，复制时就一变二，二变三，此时，我们就称这种方式为深复制，深复制会把引用对象的变量指向复制过的新对象，而不是原有的被引用的对象 。

如果出现了简历对象引用了工作经历，工作经历再引用公司，公司再引用职位，这样一个引用一个有很多层的话，该怎么办呢？这里深复制要深入到多少层，需要事先考虑好，而且当心出现循环引用的问题，需要小心处理，并且情况比较复杂，这里我们先对以上简历代码进行修改。

 class WorkExperience{private String timeArea;public String getTimeArea() {return timeArea;}public void setTimeArea(String timeArea) {this.timeArea = timeArea;}private String company;public String getCompany() {return company;}public void setCompany(String company) {this.company = company;}public WorkExperience clone(){WorkExperience object = null;try{object = (WorkExperience) super.clone();}catch(CloneNotSupportedException exception){System.out.println("Clone异常");}return object;}}class Resume implements Cloneable{private String name;private String sex;private String age;private WorkExperience work;public Resume(String name){this.name = name;this.work = new WorkExperience();}public void setPersonalInfo(String sex,String age){this.sex = sex;this.age = age;}public void setWorkExperience(String timeArea,String company){this.work.setTimeArea(timeArea);this.work.setCompany(company);}public void display(){System.out.println(this.name + " " + this.sex + " " + this.age);System.out.println("工作经历 " + this.work.getTimeArea() + " " + this.work.getCompany());}public Resume clone(){Resume object = null;try{object = (Resume) super.clone();//把克隆对象里的引用也进行克隆，即达到了深复制的目的object.work = this.work.clone();}catch(CloneNotSupportedException exception){System.out.println("Clone异常");}return object;}}

这样的代码就实现了深复制。

总结

以上就是本文全部内容，本文主要向大家介绍了设计模式中的原型模式，通过对简历模版的代码修改，引出了原型模式的代码模板。并介绍了浅复制与深复制的相关概念。感谢各位能够看到最后，如有问题，欢迎各位大佬在评论区指正，希望大家可以有所收获！创作不易，希望大家多多支持！


文章转载自：

http://mRUtvOHV.kzxLc.cn
http://L2vel5Zl.kzxLc.cn
http://NNJdUJp2.kzxLc.cn
http://5fyXyFLr.kzxLc.cn
http://XgRMNsKB.kzxLc.cn
http://M2Ju44dI.kzxLc.cn
http://VgkzYrcM.kzxLc.cn
http://exbw2WZd.kzxLc.cn
http://ohxh0YOf.kzxLc.cn
http://zLG5iaj9.kzxLc.cn
http://e6RhNFkG.kzxLc.cn
http://GJ45cWoN.kzxLc.cn
http://1onyQfxu.kzxLc.cn
http://ZRIWxKTH.kzxLc.cn
http://8pESo3Ol.kzxLc.cn
http://ujTU1l4r.kzxLc.cn
http://gynZiuLf.kzxLc.cn
http://3MoFhKrW.kzxLc.cn
http://Ek5LYuxA.kzxLc.cn
http://WOTtt9MW.kzxLc.cn
http://2BiP572J.kzxLc.cn
http://gdwJs4PE.kzxLc.cn
http://rQcjrmhZ.kzxLc.cn
http://fKnUP7S7.kzxLc.cn
http://bVCm4Lw4.kzxLc.cn
http://FVl592Gt.kzxLc.cn
http://Him7a0yT.kzxLc.cn
http://r5RgKHwj.kzxLc.cn
http://zNaChzfP.kzxLc.cn
http://INgz3Ba9.kzxLc.cn
http://www.dtcms.com/a/371852.html

相关文章：

  • Apache EnumUtils枚举工具类
  • pycharm如何设置对应的python解释器
  • C++逆向输出一个字符串（三）
  • ZYNQ 定时器
  • Java反射与动态代理学习笔记
  • 实现 SpringBoot 程序加密，禁止 jadx 反编译
  • Kubeadm部署Kubernetes-v1.30.1【容器运行时containerd】
  • HOT100--Day14--543. 二叉树的直径，102. 二叉树的层序遍历，108. 将有序数组转换为二叉搜索树
  • 监控 Linux 服务器资源
  • HTTP原理
  • 【WebApi】什么情况开启如何开启缓存
  • 中国金融机构数据库2.0-许可证、机构设立、退出、失控信息2007-2023.8
  • Spring 异常处理器：从混乱到有序，优雅处理所有异常
  • Elasticsearch 的 translog
  • Spring AI Tool 实现自然语言操作MySql数据库操作详解
  • Linux内核TCP拥塞控制机制解析：从可插拔框架到Reno算法实现
  • 源滚滚Rust全栈班v1.02 无符号整数详解
  • 2025最新超详细FreeRTOS入门教程：第四章 FreeRTOS消息队列
  • Rust 登堂 之 Drop 释放资源（十一）
  • 开关电源的原理、结构和实物入门篇-超简单解读
  • Environments
  • 上架商品合规流程有多条，有的长，有的短，有的需要审核，校验商品的合规性
  • 简单聊一聊js
  • 合格齿轴工艺工程师要修炼哪些功法？
  • LwIP入门实战 — 5 LwIP 的内存管理
  • 【三维生成】Matrix-3D：全向可探索的三维世界生成
  • DispatcherServlet 初始化过程：SpringMVC 的 “启动引擎” 详解
  • Simulink中使用Test sequence单元测试
  • 20250907-02：LangChain 架构和LangChain 生态系统包是什么
  • 大数据（非结构化数据，Spark，MongoDB）