设计模式之原型模式与深浅拷贝

已于 2023-05-30 18:02:07 修改
阅读量442 收藏
点赞数
分类专栏： 设计模式 Java基础 Spring 文章标签： java 设计模式
于 2021-05-28 01:35:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yaoyaochengxian/article/details/117342440
版权

原型模式

原型模式

背景

克隆问题

类似过程：

//原始对象
User user=new User();
user.setName("...");
//...对象属性的操作；

//如果需要克隆三个对象；
User user1=new User();
user1.setName(user.getName());
//...user1设置属性

User user2=new User();
user2.setName(user.getName());
//...user2设置属性

User user3=new User();
user3.setName(user.getName());
//...user设置属性

传统方式在创建新对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂，开发效率会变低。而且，总是需要重新初始化对象，而不是动态的获取对象运行时的状态，不够灵活；

改进

思路：Java中Object类是所有类的根类，Object类提供了一个clone()方法，该方法可以将一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个接口Cloneable。

该接口表示该类能够复制且具有复制的能力 => 原型模式

1）用原型实例指定厂家对象的种类、并且通过拷贝这些原型、创建新的对象；
2）原型模式是一种创建型设计模式、允许一个对象在创建一个可定制的对象、无需知道如何创建的细节；
3）工作原理：通过将一个原型对象传给哪个要发动创建的对象、这个要发动创建的对象通过请求原型拷贝他们自己来实施创建、 对象.clone();
在这里插入图片描述

  1. Prototype : 原型类，声明一个克隆自己的接口
  2. ConcretePrototype: 具体的原型类, 实现一个克隆自己的操作
  3. Client: 让一个原型对象克隆自己，从而创建一个新的对象(属性一样)

使用原型模式改进传统方式，让程序具有更高的效率和扩展性。

代码

package com.yxj.prototype.improve;




public class Sheep implements Cloneable {
	private String name;
	private int age;
	private String color;
	private String address = "蒙古羊";
	public Sheep(String name, int age, String color) {
		super();
		this.name = name;
		this.age = age;
		this.color = color;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	
	
	
	@Override
	public String toString() {
		return "Sheep [name=" + name + ", age=" + age + ", color=" + color + ", address=" + address + "]";
	}
	//克隆该实例，使用默认的clone方法来完成
	@Override
	protected Object clone()  {
		
		Sheep sheep = null;
		try {
			sheep = (Sheep)super.clone();
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}
		// TODO Auto-generated method stub
		return sheep;
	}
	
	
}


package com.yxj.prototype.improve;



public class Client {

	public static void main(String[] args) {
		System.out.println("原型模式完成对象的创建");
		// TODO Auto-generated method stub
		Sheep sheep = new Sheep("tom", 1, "白色");
		
		
		Sheep sheep2 = (Sheep)sheep.clone(); //克隆
		Sheep sheep3 = (Sheep)sheep.clone(); //克隆
		Sheep sheep4 = (Sheep)sheep.clone(); //克隆
		Sheep sheep5 = (Sheep)sheep.clone(); //克隆
		
		System.out.println("sheep2 =" + sheep2);
		System.out.println("sheep3 =" + sheep3);
		System.out.println("sheep4 =" + sheep4);
		System.out.println("sheep5 =" + sheep5);
	}

}

应用场景

在SpringIOC容器中，bean的类型有singleton，还有prototype;
前者是单例，后者是原型，每次从容器中获取的对象都是新的对象。


if (mbd.isSingleton()) {
    sharedInstance = this.getSingleton(beanName, () -> {
        try {
            return this.createBean(beanName, mbd, args);
        } catch (BeansException var5) {
            this.destroySingleton(beanName);
            throw var5;
        }
    });
    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
    var11 = null;

    Object prototypeInstance;
    try {
        this.beforePrototypeCreation(beanName);
        prototypeInstance = this.createBean(beanName, mbd, args);
    } finally {
        this.afterPrototypeCreation(beanName);
    }

    bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}

浅拷贝

  1. 对于数据类型是基本数据类型的成员变量、浅拷贝会直接进行值传递、将值复制一份给新的对象；
  2. 如果是引用数据类型的成员变量、浅拷贝会进行引用传递、也就是将该成员变量的引用值（内存地址）复制一份给新的对象。实际上两个对象的该成员变量都指向同一个实例。
  3. 在这种情况下、在一个对象中修改该成员变量会影响另一个对象的成员变量值；
package com.yxj.prototype.improve;

public class Sheep implements Cloneable {
	private String name;
	private int age;
	private String color;
	private String address = "蒙古羊";
	public Sheep friend; //是对象, 克隆是会如何处理
	public Sheep(String name, int age, String color) {
		super();
		this.name = name;
		this.age = age;
		this.color = color;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	
	
	
	@Override
	public String toString() {
		return "Sheep [name=" + name + ", age=" + age + ", color=" + color + ", address=" + address + "]";
	}
	//克隆该实例，使用默认的clone方法来完成
	@Override
	protected Object clone()  {
		
		Sheep sheep = null;
		try {
			sheep = (Sheep)super.clone();
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}
		// TODO Auto-generated method stub
		return sheep;
	}
	
	
}


package com.yxj.prototype.improve;



public class Client {

	public static void main(String[] args) {
		System.out.println("原型模式完成对象的创建");
		// TODO Auto-generated method stub
		Sheep sheep = new Sheep("tom", 1, "白色");
		
		sheep.friend = new Sheep("jack", 2, "黑色");
		
		Sheep sheep2 = (Sheep)sheep.clone(); //克隆
		Sheep sheep3 = (Sheep)sheep.clone(); //克隆
		Sheep sheep4 = (Sheep)sheep.clone(); //克隆
		Sheep sheep5 = (Sheep)sheep.clone(); //克隆
		
		System.out.println("sheep2 =" + sheep2 + "sheep2.friend=" + sheep2.friend.hashCode());
		System.out.println("sheep3 =" + sheep3 + "sheep3.friend=" + sheep3.friend.hashCode());
		System.out.println("sheep4 =" + sheep4 + "sheep4.friend=" + sheep4.friend.hashCode());
		System.out.println("sheep5 =" + sheep5 + "sheep5.friend=" + sheep5.friend.hashCode());
	}

}

这是浅拷贝，属性friend引用都指向堆中的同一个对象；

深拷贝

1）复制对象的所有基本数据类型的成员变量值；
2）为所有引用数据类型的成员变量申请存储空间、并复制每个引用类型成员变量所引用的对象，直到该对象可达的所有对象；也就是、对象进行深拷贝就是对整个对象进行拷贝；
3）深拷贝实现方式：重写Clone方法来实现深拷贝；
4）深拷贝实现方式2：通过对象序列化实现深拷贝；

package com.yxj.prototype.deepclone;

import java.io.Serializable;

public class DeepCloneableTarget implements Serializable, Cloneable {
	
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	private String cloneName;

	private String cloneClass;

	//构造器
	public DeepCloneableTarget(String cloneName, String cloneClass) {
		this.cloneName = cloneName;
		this.cloneClass = cloneClass;
	}

	//因为该类的属性，都是String , 因此我们这里使用默认的clone完成即可
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}


package com.yxj.prototype.deepclone;

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

public class DeepProtoType implements Serializable, Cloneable{
	
	public String name; //String 属性
	public DeepCloneableTarget deepCloneableTarget;// 引用类型
	public DeepProtoType() {
		super();
	}
	
	
	//深拷贝 - 方式 1 使用clone 方法
	@Override
	protected Object clone() throws CloneNotSupportedException {
		
		Object deep = null;
		//这里完成对基本数据类型(属性)和String的克隆
		deep = super.clone(); 
		//对引用类型的属性，进行单独处理
		DeepProtoType deepProtoType = (DeepProtoType)deep;
		deepProtoType.deepCloneableTarget  = (DeepCloneableTarget)deepCloneableTarget.clone();
		
		// TODO Auto-generated method stub
		return deepProtoType;
	}
	
	//深拷贝 - 方式2 通过对象的序列化实现 (推荐)
	
	public Object deepClone() {
		
		//创建流对象
		ByteArrayOutputStream bos = null;
		ObjectOutputStream oos = null;
		ByteArrayInputStream bis = null;
		ObjectInputStream ois = null;
		
		try {
			
			//序列化
			bos = new ByteArrayOutputStream();
			oos = new ObjectOutputStream(bos);
			oos.writeObject(this); //当前这个对象以对象流的方式输出
			
			//反序列化
			bis = new ByteArrayInputStream(bos.toByteArray());
			ois = new ObjectInputStream(bis);
			DeepProtoType copyObj = (DeepProtoType)ois.readObject();
			
			return copyObj;
			
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			return null;
		} finally {
			//关闭流
			try {
				bos.close();
				oos.close();
				bis.close();
				ois.close();
			} catch (Exception e2) {
				// TODO: handle exception
				System.out.println(e2.getMessage());
			}
		}
		
	}
	
}


package com.yxj.prototype.deepclone;

public class Client {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		DeepProtoType p = new DeepProtoType();
		p.name = "宋江";
		p.deepCloneableTarget = new DeepCloneableTarget("大牛", "小牛");
		
		//方式1 完成深拷贝
		
//		DeepProtoType p2 = (DeepProtoType) p.clone();
//		
//		System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
//		System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
	
		//方式2 完成深拷贝
		DeepProtoType p2 = (DeepProtoType) p.deepClone();
		
		System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
		System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
	
	}

}

注意事项与细节

  1. 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率
  2. 不用重新初始化对象，而是动态地获得对象运行时的状态
  3. 如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，无需修改代码
  4. 在实现深克隆的时候可能需要比较复杂的代码
  5. 缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了ocp原则，这点请同学们注意
问道玄霄
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
设计模式-值类型与引用类型、深拷贝与浅拷贝、原型模式详解
Linuxhus的博客
02-11 696
(1). 分类值类型包括：布尔类型、浮点类型(float、double、decimal、byte)、字符类型(char)、整型（int、long、short等）、枚举(entum)、结构体(struct)。引用类型：数组、字符串(string)、类、接口、委托(delegate)。(2).内存存储值类型数据存放在栈stack中， 引用类型地址存放栈stack中，数据存放在堆heap中。值类型变量声明后，不管是否赋值，都会在在栈中分配内存空间。
设计模式普及之原型模式
小生不得无礼的博客
07-23 108
原型模式的定义： 用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。 原型模式的使用场景： 1.类初始化需要消耗非常多的资源，包括数据、硬件资源等； 2.通过new产生一个对象需要非常繁琐的数据准备或访问权限； 3.一个对象需要提供给其他对象访问，而且各个调用者可能度需要修改其值时。 简单实现的方式： 实现Cloneable接口，重写clone方法 public cl...
设计模式-原型模式(深拷贝) #java基础#设计模式
jupiter_windy的博客
07-29 227
浅拷贝：拷贝了对象的基本数据类型或其封装类，对于内部的数组、引用对象依旧是采用引用的形式； @Data public class TestEntity implements Cloneable{ private String testAid; private String testAname; private TestEntityB testEntityB; ...
设计模式之【原型模式】，深入理解深拷贝与浅拷贝
秃了也弱了
12-16 741
原型模式： 用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。对于熟悉 JavaScript 语言的前端程序员来说，原型模式是一种比较常用的开发模式。这是因为，有别于 Java、C++ 等基于类的面向对象编程语言，JavaScript 是一种基于原型的面向对象编程语言。即便 JavaScript 现在也引入了类的概念，但它也只是基于原型的语法糖而已。不过，如果你熟悉的是 Java、C++ 等这些编程语言，那在实际的开发中，就很少用到原型模式了。
设计模式之—原型模式(深拷贝与浅拷贝)
KKK
01-12 375
原型模式
设计模式——原型设计模式（浅拷贝+深拷贝）
zjcoming
03-08 455
什么是原型设计模式 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 说白了原型模式就是通过拷贝的方式创建你要的对象，要拷贝得有个前提就是得先有一个模型。 案例引出（为什么需要原型模式？& 什么时候需要？） 举个例子，比如有一天，周杰伦到奶茶店点了一份不加冰的原味奶茶，你说我是周杰伦的忠实粉，我也要一份跟周杰伦一样的。用程序表示如下： 奶茶类： public class MilkTea { public String type; public bo..
设计模式-----原型模式
m0_37671741的博客
09-13 204
一、基本理解 原型模式：在软件系统中，有些对象的创建过程较为复杂，而且有时候需要频繁创建，原型模式通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象，这就是原型模式。 理解：原型模式是通过给出一个原型对象来指明所创建的对象的类型，然后使用自身实现的克隆接口来复制这个原型对象，该模式就是用这种方式来创建出更多同类型的对象。使用这种方式创建新的对象，就无需通过new关键字来实例化对象。这是因为Object类的clone方法是一个本地方法，它可以直接操作内存
设计模式：创建型之原型（深浅拷贝）、单例（饿汉式与懒汉式），三大工厂模式 结构型之适配器模式，代理模式（三大代理）
最新发布
04-25
原型模式用来解决对象的创建问题，它是指用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的对象 工厂模式将目的将创建对象的具体过程屏蔽隔离起来、解耦：将对象的创建和使用的过程...
C#深浅拷贝的深入解析
12-25
前面我们学习完了设计模式，在其中我们有了解到原型模式。这里涉及到了克隆自身对象。那么也就是对对象进行拷贝。这里就涉及到了这么一个概念。深浅拷贝、何为深拷贝何为浅拷贝呢？我们一起来看看吧。 浅拷贝 首先...
java源代码实例系列之三供参考
07-07
9. 复制与深浅拷贝：在Java中，复制对象分为浅拷贝和深拷贝两种，它们对于理解和处理对象间的引用关系至关重要。这部分可能涉及Object类的clone()方法和序列化技术。 10. 多线程：Java提供了内置的多线程支持，通过...
前端 二阶段 js 复习总纲规划
03-27
包含了js 的所有的知识点，包括 js 基础知识，es6，正则，promise,事件轮询，定时器，跨域，继承，深浅拷贝，闭包，设计模式，前后端交互等等，复习总纲。方便大家查询与复习，对于初学JS学员来说可以少走很多弯路...
设计模式--原型模式（2）--深拷贝&浅拷贝
Masha
06-16 117
设计模式–原型模式（1） https://blog.csdn.net/yangyanjava/article/details/106790859 浅克隆 1:直接调用clone方式 public class Sheep implements Cloneable { String name; Sheep friends; Sheep(String name) { this.name = name; } @Override protected
Redis多级缓存架构、缓存设计、布隆过滤器
玄霄
06-23 4834
Redis多级缓存架构、缓存设计、性能优化多级缓存架构缓存设计缓存穿透解决方法缓存雪崩解决方案 多级缓存架构 Nginx层：Lua动态渲染模板 一些静态资源、例如HTML、CSS、JS、图片资源等都可以独立部署在一台服务器上、加载进Redis缓存中。用户请求经过Nginx时、判断是否为静态资源、是则直接从静态资源服务器里面获取、不用经过后端的Web层和Redis集群； Web层缓存 Web层里面会有一些Ehcache缓存、可以使用HashMap、ConcurrentHashMap、ArrayList等数
Session、Cookie、Token、单点登录
玄霄
05-22 4171
Session、Cookie、Token、单点登录HTTP无状态Cookiecookie认证流程图缺点Session认证过程session认证的流程图token认证token认证的流程图优缺点JWT认证JWT认证流程图基于session认证的单点登录单点登录基于session认证的单点登录流程图基于JWT的单点登录Cookie 和 Session 的区别Token 和 Session 的区别Token 和 JWT 的区别相同区别使用 cookie 时需要考虑的问题使用 session 时需要考虑的问题分布式
WebSocket并搭建简易聊天室
玄霄
07-05 3576
WebSocketWebSocketWebSocket特点代码基本框架客户端服务端代码示例发送与接收客户端实现服务端实现长连接在线聊天室设计思路客户端服务端代码存在的问题用户身份解决方法用户姓名的显示代码并发优化解决方法 WebSocket WebSocket，是一个基于TCP的通讯协议，适用于网站应用。 HTTP：短连接的TCP协议 WebSocket: 长连接的TCP协议 常见的应用场景:基于Web的聊天室、在线客服 WebSocket特点 单一TCP长连接，采用全双工通信模式（HTTP是半双工，
JVM垃圾收集器G1
玄霄
05-09 3429
JVM垃圾收集器G1G1收集器G1的垃圾回收过程G1特点G1垃圾收集分类Young GCMixed GCFull GCG1收集器参数设置G1收集器优化建议G1使用场景每秒几十万并发的系统如何优化JVM如何选择垃圾收集器安全点与安全区域安全点安全区域 G1收集器 G1是面向服务器的垃圾收集器，主要针对配备多核处理以及大容器内存的及其，极高概率满足GC停顿时间要求，还具备高吞吐量特征； G1将Java堆划分为多个大小相等的独立区域Region，JVM最多可以有2048个Region； 一般Region大小等
公平锁、非公平锁、可重入锁、自旋锁、读写锁
玄霄
06-05 1974
并发编程多种锁公平锁与非公平锁公平锁和非公平锁的区别synchronized与ReentrantLock的区别可重入锁代码示例自旋锁自旋锁代码示例独占锁（写锁）、共享锁（读锁）、互斥锁ReentrantReadWriteLock源码 公平锁与非公平锁 公平锁 指多个线程按照申请锁的顺序来获取锁，按照先来先服务的原则。其落地实现可使用队列。 非公平锁 多个线程获取锁的方式不是按照申请锁的顺序，后申请锁的线程可以比先申请锁的线程先获得锁。 JUC下的ReentrantLock的构造boolean值参
深入理解Automatic、CAS、Unsafe类
玄霄
06-08 1638
Automatic与Unsafe类Automatic类i++在并发场景下存在的问题三级目录 Automatic类 原子操作：不可被中断的一个或一系列操作 i++在并发场景下存在的问题 实例代码： class MyData{ int number=0; public void addPlusPlus(){ number++; } private static void atomicDemo() { System.out.println("原子性测试");
设计模式原理与应用之创建型模式.pptx
09-28
设计模式原理与应用中提到的创建型模式主要包括Singleton（单例）、Prototype（原型）、Factory Method（工厂方法）、Abstract Factory（抽象工厂）和Builder（生成器）等几种模式。 Singleton模式是创建型模式中的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值