【大话设计模式-6】原型模式（浅拷贝、深拷贝案例分析）

最新推荐文章于 2020-12-16 10:47:48 发布
最新推荐文章于 2020-12-16 10:47:48 发布
阅读量254 收藏
点赞数 1
分类专栏： # 设计模式学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43925089/article/details/107506640
版权

文章目录

1. 克隆羊问题

现在有一只羊 tom，姓名为: tom, 年龄为：1，颜色为：白色，请编写程序创建和 tom 羊 属性完全相同的 10只羊。

2. 传统方式解决克隆羊问题

  1. 思路分析(图解)
    在这里插入图片描述
  2. 代码的演示
package com.atguigu.prototype;
public class Client {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//传统的方法
		Sheep sheep = new Sheep("tom", 1, "白色");
		Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
		Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
		Sheep sheep4 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
		Sheep sheep5 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
		//.... System.out.println(sheep);
		System.out.println(sheep2);
		System.out.println(sheep3);
		System.out.println(sheep4);
		System.out.println(sheep5);
	 }
}

在这里插入图片描述

3. 传统的方式的优缺点

  1. 优点是比较好理解，简单易操作。
  2. 在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低
  3. 总是需要重新初始化对象，而不是动态地获得对象运行时的状态, 不够灵活
  4. 改进的思路分析
    思路：Java 中 Object 类是所有类的根类，Object 类提供了一个 clone()方法，该方法可以将一个 Java 对象复制一份，但是需要实现 clone 的 Java 类必须要实现一个接口 Cloneable，该接口表示该类能够复制且具有复制的能力 =>原型模式

4. 原型模式-基本介绍

  1. 原型模式(Prototype 模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象
  2. 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节
  3. 工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它
    们自己来实施创建，即 对象.clone()
  4. 形象的理解：孙大圣拔出猴毛， 变出其它孙大圣

5. 原型模式原理结构图-uml 类图

在这里插入图片描述
原理结构图说明

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

6. 原型模式解决克隆羊问题的应用实例

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

package com.atguigu.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) {
			System.out.println(e.getMessage());
		}
		// TODO Auto-generated method stub
		return sheep;
	}
}

package com.atguigu.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());
	}
}

在这里插入图片描述

7. 原型模式在 Spring 框架中源码分析

  1. Spring 中原型 bean 的创建，就是原型模式的应用
  2. 代码分析+Debug 源码
package com.atguigu.spring.bean;

/**
 * 注释
 * @author Administrator
 *
 */
public class Monster {

	private Integer id = 10 ;
	private String nickname = "牛魔王";
	private String skill = "芭蕉扇";
	public Monster() {
		
		System.out.println("monster 创建..");
	}
	public Monster(Integer id, String nickname, String skill) {
		//System.out.println("Integer id, String nickname, String skill被调用");
		this.id = id;
		this.nickname = nickname;
		this.skill = skill;
	}
	
	public Monster( String nickname, String skill,Integer id) {
		
		this.id = id;
		this.nickname = nickname;
		this.skill = skill;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getNickname() {
		return nickname;
	}
	public void setNickname(String nickname) {
		this.nickname = nickname;
	}
	public String getSkill() {
		return skill;
	}
	public void setSkill(String skill) {
		this.skill = skill;
	}
	@Override
	public String toString() {
		return "Monster [id=" + id + ", nickname=" + nickname + ", skill="
				+ skill + "]";
	}
}

beans.xml

//prototype代表创建bean时，是以原型模式创建的
<bean id="id01" class="com.atguigu.spring.bean.Monster" scope="prototype"/>

Test.java

package com.atguigu.spring.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class ProtoType {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
		// 获取monster[通过id获取monster]
		Object bean = applicationContext.getBean("id01");
		System.out.println("bean" + bean); // 输出 "牛魔王" .....
		Object bean2 = applicationContext.getBean("id01");
		System.out.println("bean2" + bean2); //输出 "牛魔王" .....
		System.out.println(bean == bean2); // false
		// ConfigurableApplicationContext
	}
}

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

8. 深入讨论-浅拷贝和深拷贝

8.1 浅拷贝的介绍

  1. 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。
  2. 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
  3. 前面我们克隆羊就是浅拷贝。
  4. 浅拷贝是使用默认的 clone()方法来实现。
    sheep = (Sheep) super.clone();

8.2 深拷贝基本介绍

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

9. 深拷贝应用实例

序列化视频讲解（一）
序列化视频讲解（二）
序列化案例讲解

  1. 使用 重写 clone 方法实现深拷贝
  2. 使用序列化来实现深拷贝
  3. 代码演示
package com.atguigu.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.atguigu.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());//bos字节数组输出流反序列化--》读进来（相当于把对象进行克隆）
			ois = new ObjectInputStream(bis);//ois就读到了原先序列化出去的对象（this）
			DeepProtoType copyObj = (DeepProtoType)ois.readObject();//以对象的方式从内存读回来输出的对象
			return copyObj;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		} finally {
			//关闭流
			try {
				bos.close();
				oos.close();
				bis.close();
				ois.close();
			} catch (Exception e2) {
				System.out.println(e2.getMessage());
			}
		}
	}
}

//Client.java
package com.atguigu.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());
	}
}

在这里插入图片描述

10. 原型模式的注意事项和细节

  1. 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率
  2. 不用重新初始化对象，而是动态地获得对象运行时的状态
  3. 如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，无需修改代码
  4. 在实现深克隆的时候可能需要比较复杂的代码
  5. 缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了 ocp 原则，这点请同学们注意.
计忆芳华
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
大话设计模式-完整设计模式介绍
10-23
大话设计模式 完整设计模式介绍
原型模式——浅克隆和深克隆
qq_39368007的博客
02-23 744
概述 用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。 结构 原型模式包含如下角色： 抽象原型类：规定了具体原型对象必须实现的的 clone() 方法。 具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。 访问类：使用具体原型类中的 clone() 方法来复制新的对象。 接口类图如下： 实现 原型模式的克隆分为浅克隆和深克隆 浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象.
原型模式案例详解-浅拷贝与深拷贝
weixin_44802104的博客
07-22 181
克隆羊问题 现在有一只羊，姓名为：tom，年龄为：1，颜色为：白色，请编写程序创建和tom羊属性完全相同的10只羊。 传统方式解决克隆羊问题 public class Sheep { private String name; private int age; private String color; public Sheep(String name, int age, String color) { this.name = name; t
创建型设计模式-----原型模式（浅克隆、深克隆）
machine_Heaven的博客
03-21 545
今天继续讲创建型设计模式中的原型模式，大家可以从标题中略微猜测一下，这个原型模式是个什么东东。 简介 定义：用原型实例创建对象的种类，然后通过复制这些原型创建新的实例。无须知道具体的创建细节。 动机：使用原型模式来复制一个对象，从而克隆出多个一模一样的对象。 说到这里大家应该明白了，这个原型模式其实就是克隆。当然克隆也有深克隆和浅克隆，下面举例子的时候我会说明的。 模型结构图： 说明： Prot...
大话设计模式之原型模式中的复制
生命不止 学无止境
03-06 1747
在软件中，创建一个对象需要花费不少时间，远没有选中，然后Ctrl C与Ctrl V来的快，通过这两个快捷键，就产生了你想要的一模一样的东东，虽然东东一样，但是内存地却不一样，这就跟设计模式中的原型模式差不多，我个人觉得，Ctrl C与Ctrl V就是原型模式的最好应用。 原型模式： 概念：        用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。其实就是从一个对象再创建
浅/深克隆——原型模式
小青的博客
11-17 254
原型模式 ​ Prototype Pattern：原型模式属于GoF23种设计模式中的创建型模式的一种，提供的是一种最佳的重复创建对象的方式。 ​ 简单的理解呢，原型模式的作用就是用一个已经存在了的对象，再去创建另外一个相同的对象，并且不需要知道这个对象创建需要什么，或者说是怎么创建出来的，而是直接拿到这个新的对象，再说的简单点就是克隆了。 结构 ​ 原型模式这个模式的概念还是很简单的，可以简...
读《大话设计模式》－代理模式(proxy)
02-03
代理模式(proxy)为其他对象提供一个代理以控制对这个对象的访问。结构图//Subject类，定义了RealSubjext和Proxy的公共接口，这样就在任何使用RealSubject的地方可以使用ProxyclassSubject{public:virtualvoidRequest...
《大话设计模式》Java版的实现案例源码.zip
最新发布
02-20
《大话设计模式》Java版的实现案例源码.zip
大话设计模式--Singleton(单例模式)
03-28
NULL 博文链接：https://linxingliang.iteye.com/blog/1217811
大话模式源代码-02策略模式
07-22
大话模式源代码-02策略模式 多个案例源代码，均可直接使用
设计模式：原型模式介绍 && 原型模式的深拷贝问题
LifeGoesOn
08-12 308
0、背景 克隆羊问题：有一个羊，是一个类，有对应的属性，要求创建完全一样的10只羊出来。 那么实现起来很简单，我们先写出羊的类： public class Sheep { private String name; private int age; private String color; //下面写上对应的get和set方法，以及对应的构造器 } 然后，创建10只一样的羊，就在客户端写一个代码创建： //原始羊 Sheep sheep = new Sheep("tom
原型模式 -- 拷贝当前对象的副本
智多牛 - 俯首甘为孺子牛！
01-14 1197
张纪中版《西游记》以出乎意料的造型和雷人的台词遭到广大观众朋友的热议，我们在此对该话题不作过多讨论。但无论是哪个版本的《西游记》，孙悟空都是其中的一号雄性主角，关于他（或它）拔毛变小猴的故事几乎人人皆知，孙悟空可以用猴毛根据自己的形象，复制（又称“克隆”或“拷贝”）出很多跟自己长得一模一样的“身外身”来。在设计模式中也存在一个类似的模式，可以通过一个原型对象克隆出多个一模一样的对象，该模式称之为原
Java原型设计模式
m0_45097637的博客
06-23 341
文章目录克隆羊问题传统方式解决克隆羊问题思路图解代码实现传统的方式的优缺点原型模式基本介绍原型模式实例代码原型模式在Spring框架中源码分析深入讨论原型模式的浅拷贝和深拷贝浅拷贝的介绍深拷贝基本介绍深拷贝实现代码原型模式的注意事项和细节 克隆羊问题 现在有一只羊 tom，姓名为: tom, 年龄为：1，颜色为：白色，请编写程序创建和 tom 羊 属性完全相同的 10 只羊。 传统方式解决克隆羊问题 思路图解 代码实现 羊 public class Sheep { private String name
小白必备之原型模式总结(浅克隆和深克隆)
Code皮皮虾的博客
08-01 644
文章目录原型模式-基本介绍传统方式原型模式解决原型模式(浅拷贝与深拷贝)浅拷贝深拷贝总结 原型模式-基本介绍 原型模式(Prototype模式)是指：用原型实例指定创建对象地种类，并且通过拷贝这些原型，创建新的对象。 原型模式是一种创建型设计模式，允许一个对象再创建另一个可定制地对象，无需知道创建细节。 工作原理：通过一个原型对象传给要发动创建地对象，这个要发动创建地对象通过请求原型对象拷贝他们自己来实施创建，即 对象.clone() 优点： 性能提高。 逃避构造函数的约束。 缺点： 配备克隆方法
大话设计模式——错误汇总1
sunny_LI
04-26 1315
在Microsoft Vistual Studio的环境及C#语法知识还不熟悉的时候，出现的那些初级错误，回想起来感觉是那么地可爱。现在把那些错误汇总如下： 1.无法创建抽象类或接口的实例         类名写错了位置，在添加类之后，创建类写错了位置。应该这么写——interface 与class并列，可以在命名空间下并列存在。添加类有两种方式—— 一种是通过菜单添加，一种是直接写代码。因着
设计模式之实验二： 创建型设计模式实验
夏曦
12-16 7627
实验项目二： 创建型设计模式实验 （1）实验目的与原理 ①结合实例,熟练绘制创建型设计模式结构图。 ②结合实例,熟练使用Java面向对象编程语言实现创建型设计模式。 ③通过编程实践，理解每一种创建型设计模式的概念和内涵、结构、优缺点以及应用场景。 （2）实验内容与步骤 ①使用简单工厂模式设计一个可以创建不同几何形状( Shape)(例如圆形( Circle).、矩形 Rectangle)和三角形( ( Triangle)等的绘图工具类,每个几何图形均具有绘制方法daw()和擦除方法 erase(),要求在绘
原型设计模式(浅克隆和深克隆)
baidu_24545901的博客
03-07 1492
原型模式用于创建重复对象并且保证性能，它属于是一种创建型的设计模式，提供了一种创建对象的最佳方式。该设计模式用于实现一个原型接口，该接口用于创建当前对象的克隆对象。应用实例场景：  可以想象成细胞分裂、克隆羊多利、孙悟空拔一根猴毛，吹出千万个。首先我们有一个要被克隆的原始 羊 这个类如下：public class Sheep implements Cloneable{ private Stri...
原型模式深拷贝的代码案例——设计模式笔记
weixin_43484977的博客
06-06 130
public class Client { public static void main(String[] args) throws CloneNotSupportedException { // TODO Auto-generated method stub DeepCloneableTarget p=new DeepCloneableTarget(); p.name="Jack"; p.deep1=new DeepcloneTarget("猩猩","你好");
设计原型之原型模式
weixin_48479053的博客
09-12 112
原型模式定义与理解 定义：有些对象的创建过程较为复杂，而且有时候需要频繁创建，原型模式通过给一个原型对象来指明所要创建的对象类型。然后用复制这个原型对象的方法创建更多同类型的对象，这就是原型模式。 原型模式简单实现 需要去实现Cloneable接口，在JVM中只有实现这个接口的类才能被拷贝，否则会抛出CloneNotSupportedException异常。 重写Object类中的clone方法，Object类是所有类的父类，而Object类中的clone方法是返回对象的一个拷贝。 在重写的clone方法
大话设计模式 c++
09-13
在大话设计模式中，作者通过讲述故事的形式，生动地介绍了23种设计模式，包括创建型模式、结构型模式和行为型模式。其中创建型模式包括简单工厂模式、工厂方法模式、抽象工厂模式、单例模式、原型模式和建造者模式；...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

计忆芳华

制作不易，欢迎打赏

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值