被说了很多遍的设计模式---原型模式

最新推荐文章于 2023-01-27 13:56:48 发布
最新推荐文章于 2023-01-27 13:56:48 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式 原型模式 教程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ABCD898989/article/details/52872286
版权

[把你的理性思维慢慢变成条件反射]

本文，我们讲介绍原型模式，文章主题结构与上位一致。惯例，先来看看我们示例工程的环境：

操作系统：win7 x64

其他软件：eclipse mars，jdk7

-------------------------------------------------------------------------------------------------------------------------------------

经典问题：

对象复制，克隆。

思路分析：

要点一：支持浅克隆。

要点二：支持深克隆。

示例工程：

错误写法：

创建Templet.java文件，具体内容如下：

package com.csdn.ingo.gof_prototype;

public class Window {
	public static void main(String[] args) {
		Templet a = new Templet("TempletA");
		a.setContext("AAAAA");
		a.setTime("010101");
		a.setCompany("CompanyA");
		
		Templet b = a;
		b.setName("TempletB");
		Templet c = a;
		c.setName("TempletC");
		
		a.display();
		b.display();
		c.display();
		System.out.println(a.hashCode());
		System.out.println(b.hashCode());
		System.out.println(c.hashCode());
	}
}

错误原因：

首先，我们先观察上面main方法输出内容：

name:TempletC,context:AAAAA,time:010101,company:CompanyA
name:TempletC,context:AAAAA,time:010101,company:CompanyA
name:TempletC,context:AAAAA,time:010101,company:CompanyA
17198255
17198255
17198255
ABC三个对象在内存当中的地址完全相同，即代表同一个对象。（这部分概念非常基础，请各位看官牢记）。

推荐写法（1）：浅克隆（值类型）


创建Prototype.java文件，具体内容如下：

package com.csdn.ingo.gof_prototype.one;

public abstract class Prototype {
	
	private String id;
	
	public Prototype(String id){
		this.id=id;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	
	public abstract Prototype Clone();
}
创建ConcretePrototypeA文件，具体内容如下： 

package com.csdn.ingo.gof_prototype.one;

public class ConcretePrototypeA extends Prototype implements Cloneable {

	public ConcretePrototypeA(String id) {
		super(id);
	}

	@Override
	public Prototype Clone() {
		return (Prototype) this.clone();
	}

	@Override
	public Object clone() {
		ConcretePrototypeA cpa = null;
		try {
			cpa = (ConcretePrototypeA) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return cpa;
	}
}
创建Window.java文件，具体内容如下： 

package com.csdn.ingo.gof_prototype.one;

public class Window {
	public static void main(String[] args) {
		ConcretePrototypeA a = new ConcretePrototypeA("ingo");
		ConcretePrototypeA b = (ConcretePrototypeA)a.Clone();
		System.out.println(a.hashCode());
		System.out.println(b.hashCode());
	}
}
观察输出： 

1149197
20761102

推荐写法（2）：浅克隆（引用类型）


创建Collection.java文件，具体内容如下：

package com.csdn.ingo.gof_prototype.two;

import com.csdn.ingo.gof_prototype.one.ConcretePrototypeA;

public class Collection implements Cloneable {
	private String prop1;
	private String prop2;
	
	public String getProp1() {
		return prop1;
	}
	public void setProp1(String prop1) {
		this.prop1 = prop1;
	}
	public String getProp2() {
		return prop2;
	}
	public void setProp2(String prop2) {
		this.prop2 = prop2;
	}
	@Override
	public Object clone() {
		Collection co = null;
		try {
			co = (Collection) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return co;
	}
}
创建ConcretePrototypeA.java文件，具体内容如下： 
package com.csdn.ingo.gof_prototype.two;

public class ConcretePrototypeA extends Prototype implements Cloneable {
	private Collection collection =new Collection();
	
	public Collection getCollection() {
		return collection;
	}

	public void setCollection(Collection collection) {
		this.collection = collection;
	}

	public ConcretePrototypeA(String id) {
		super(id);
	}

	@Override
	public Prototype Clone() {
		return (Prototype) this.clone();
	}

	@Override
	public Object clone() {
		ConcretePrototypeA ca = null;
		try {
			ca = (ConcretePrototypeA) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return ca;
	}
}
创建Prototype.java文件，具体内容如下： 

package com.csdn.ingo.gof_prototype.two;

public abstract class Prototype {
	
	private String id;
	
	public Prototype(String id){
		this.id=id;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	
	public abstract Prototype Clone();
}
创建Window.java文件，具体内容如下： 

package com.csdn.ingo.gof_prototype.two;

public class Window {
	public static void main(String[] args) {
		ConcretePrototypeA a = new ConcretePrototypeA("ingo");
		ConcretePrototypeA b = (ConcretePrototypeA)a.Clone();
		Collection ca = a.getCollection();
		ca.setProp1("a1");
		ca.setProp2("a2");
		Collection cb = b.getCollection();
		cb.setProp1("b1");
		cb.setProp2("b2");
		System.out.println(a.hashCode());
		System.out.println(b.hashCode());
		System.out.println(a.getCollection().hashCode());
		System.out.println(b.getCollection().hashCode());
	}
}
观察输出： 

1396421
15105042
31164770
31164770

推荐写法（3）：深克隆（专用）


创建Colleation.java文件，具体内容如下：

package com.csdn.ingo.gof_prototype.three;

import com.csdn.ingo.gof_prototype.two.ConcretePrototypeA;

public class Collection implements Cloneable{
	
	private String date;
	private String company;
	public String getDate() {
		return date;
	}
	public void setDate(String date) {
		this.date = date;
	}
	public String getCompany() {
		return company;
	}
	public void setCompany(String company) {
		this.company = company;
	}
	@Override
	public Object clone(){
		Collection ca = null;
		try {
			ca = (Collection) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return ca;
	}
	@Override
	public String toString() {
		return "Collection [date=" + date + ", company=" + company + "]";
	}
}
创建Prototype.java文件，具体内容如下： 
package com.csdn.ingo.gof_prototype.three;

public class Prototype implements Cloneable {
	private String name;
	private Collection work;
	public Prototype(String name){
		this.name = name;
		work = new Collection();
	}
	private Prototype(Collection work){
		this.work = (Collection)work.clone();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Collection getWork() {
		return work;
	}
	public void setWork(Collection work) {
		this.work = work;
	}
	public void setWke(String date,String company){
		work.setDate(date);
		work.setCompany(company);
	}
	@Override
	public String toString() {
		return "Prototype [name=" + name + ", work=" + work.toString() + "]";
	}
	@Override
	public Object clone(){
		Prototype ca = new Prototype(this.work);
		ca.setName(name);
		return ca;
	}
}
创建Window.java文件，具体内容如下： 
package com.csdn.ingo.gof_prototype.three;

public class Window {

	public static void main(String[] args) {
		Prototype a = new Prototype("ingo");
		System.out.println(a.hashCode());
		a.setWke("01", "aaa");
		Prototype b = (Prototype)a.clone();
		System.out.println(b.hashCode());
		b.setWke("02", "bbb");
		Prototype c = (Prototype)a.clone();
		System.out.println(c.hashCode());
		c.setWke("03", "ccc");
		System.out.println(a.toString());
		System.out.println(b.toString());
		System.out.println(c.toString());
	}
}

推荐写法（4）：深克隆（通用）


创建Collection.java文件，具体内容如下：

package com.csdn.ingo.gof_prototype.four;

import java.io.Serializable;

public class Collection implements Serializable {
	private static final long serialVersionUID = 1L;
	private String date;
	private String company;

	public String getDate() {
		return date;
	}

	public void setDate(String date) {
		this.date = date;
	}

	public String getCompany() {
		return company;
	}

	public void setCompany(String company) {
		this.company = company;
	}

	@Override
	public Object clone() {
		Collection ca = null;
		try {
			ca = (Collection) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return ca;
	}

	@Override
	public String toString() {
		return "Collection [date=" + date + ", company=" + company + "]";
	}
}

创建Prototype.java文件，具体内容如下；

package com.csdn.ingo.gof_prototype.four;

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 Prototype implements Serializable {

	private static final long serialVersionUID = 1L;
	private String name;
	private Collection work;

	public Prototype(String name) {
		this.name = name;
		work = new Collection();
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Collection getWork() {
		return work;
	}

	public void setWork(Collection work) {
		this.work = work;
	}

	public void setWke(String date, String company) {
		work.setDate(date);
		work.setCompany(company);
	}

	@Override
	public String toString() {
		return "Prototype [name=" + name + ", work=" + work.toString() + "]";
	}

	public Prototype clone() {
		ByteArrayOutputStream bao = new ByteArrayOutputStream();
		ObjectOutputStream oos;
		try {
			oos = new ObjectOutputStream(bao);
			oos.writeObject(this);

			ByteArrayInputStream bis = new ByteArrayInputStream(bao.toByteArray());
			ObjectInputStream ois;
			ois = new ObjectInputStream(bis);
			return (Prototype) ois.readObject();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
}
创建Window.java文件，具体内容如下： 

package com.csdn.ingo.gof_prototype.four;

public class Window {

	public static void main(String[] args) {
		Prototype a = new Prototype("ingo");
		System.out.println(a.hashCode());
		a.setWke("01", "aaa");
		Prototype b = (Prototype)a.clone();
		System.out.println(b.hashCode());
		b.setWke("02", "bbb");
		Prototype c = (Prototype)a.clone();
		System.out.println(c.hashCode());
		c.setWke("03", "ccc");
		System.out.println(a.toString());
		System.out.println(b.toString());
		System.out.println(c.toString());
	}
}<span style="font-family:Microsoft YaHei;font-size:14px;">
</span>

问题：浅克隆与深克隆的区别？

浅克隆：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。换句话说：对象成员变量中的简单类型都被复制，而引用对象类型，只复制引用，仍然指向原有对象，该对象仍然只有一份。

深克隆：被复制对象的所有变量都含有与原来的对象相同的值，所有的对其他对象的引用也复制一份引用的对象。换句话说：对象成员变量中的简单类型都被复制，而引用对象类型，不止复制引用，而是将引用对象也复制一份。

模式总结：

标准UML结构图：


概念总结：

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

组成部分：Prototype（原型类），ConcretePrototype（具体子类）两部分组成。

注：本文仅以Java为例说明，其他语言的原型模式，请各位看官自行学习。

反思：

应用场景：

  1. 创建相似的对象。
  2. 在上面的基础之上，创建新对象的花费资源较多，耗时较长的场景。
  3. 对象变化较小，并需要长时间保存时，在系统内创建备份时。
  4. 对象中含有组合属性，并且对象数量较少，考虑执行效率时。

优点：

  1. 当对象较为复杂，通过原型模式可以简化创建过程，提高创建效率。
  2. 扩展性好。客户端直接与抽象类进行交互，提高了双方的灵活性，扩展性。
  3. 提供深克隆，浅克隆两种方式供其使用。

缺点：

  1. 必须要为每一个对象创建一个克隆方法，克隆对象的任何改变，将直接违反“开闭原则”。
  2. 深克隆的过程需要IO等多个复杂过程。需要及时处理异常情况。
  3. 深层嵌套的克隆难于管理及实现。

-------------------------------------------------------------------------------------------------------------------------------------

至此，被说了很多遍的设计模式---原型模式 结束


参考资料：

图书：《大话设计模式》

其他博文：http://blog.csdn.NET/lovelion/article/details/7563445


y-yg
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++20设计模式-第4章-原型模式代码
02-05
总结，原型模式在C++20中仍然是一种有效的设计模式，通过合理的继承和多态性，可以轻松地实现对象的复制。虽然C++20没有直接提供相关支持，但新特性使得我们的代码更加现代化和高效。在实际开发中，合理利用原型模式...
iOS设计模式-原型设计模式
10-07
总的来说，原型设计模式在iOS开发中提供了高效的对象复制机制，有助于减少代码复杂性，提高性能，尤其是在处理大量相似但略有不同的对象时。正确理解和应用原型设计模式，可以使你的iOS应用更加健壮和易于维护。
Java设计模式-工厂设计模式
MarsKang的博客
02-09 293
最近经理让我们整理一下java的设计模式看了许多网上的PPT，文档，感觉这写模式还是写在例子中才能更快的理解他的用法。 好了废话不多说了直接上代码 假如我们要做个生产鱼的工厂1.首先我们需要实体类鱼作为我们要生产的东西public abstract class Fish { public abstract String introduce();//介绍 public abstract
原型模式
jingan欢迎您来访
09-17 112
先看代码： /** * Comments: 深克隆与浅克隆 * ProjectName: parent * * @author camel * @date 2020/9/16 23:53 */ public class ProtoClone implements Cloneable , Serializable { private Integer age; private String name; private List<String> hobb
设计模式 - 创建型模式_原型模式
热门推荐
小工匠
01-27 2万+
原型模式主要解决的问题就是创建重复对象，⽽这部分 对象 内容本身⽐较复杂，⽣成过程可能从库或者RPC接⼝中获取数据的耗时较⻓，因此采⽤克隆的⽅式节省时间。
Java设计模式-创建型设计模式-原型模式
Fatter$hday的博客
04-20 1208
Java设计模式-创建型设计模式-原型模式
设计模式 - Prototype 原型模式
敖丙
05-18 4106
我看行
深入理解设计模式-原型模式
少说，多做
05-19 8194
文章目录一、定义二、使用场景三、代码样例1.类图2.简历实体类3.工作经历实体类4.客户端类4.输出四、优缺点五、两种实现方式：浅拷贝与深拷贝1.浅拷贝2.深拷贝结尾 一、定义 原型模式使用原型实例指定创建对象的种类，并且通过拷贝原型对象创建新的对象。原型模式本质是一种克隆对象的方法，其核心是重写Object中的clone方法，调用该方法可以在内存中进行对象拷贝。 Java提供了一个标记接口——Cloneable，实现该接口完成标记，在JVM中具有这个标记的对象才有可能被拷贝。如果不实现该接口，克隆对象会
设计模式 - 原型模式
Circ
04-14 4490
原型模式是什么 原型（Prototype）模式的定义如下：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。例如，Windows 操作系统的安装通常较耗时，如果复制就快了很多。在生活中复制的例子非常多，这里不一一列举了。 使用情景： 首先从实际生活来了解原型模式的由来，假设你有一份非常好的讲义，你的朋友也想要一份，那么怎么办？重新手抄一份？显然不是，当然是用复印机复印一份来得方
津津乐道设计模式 - 原型模式详解
傲泣龙腾的博客
04-14 2615
津津乐道设计模式 - 原型模式详解1、什么是原型模式2、浅克隆3、深克隆4、结语 1、什么是原型模式 在讲解什么是原型模式之前，先看看我们项目中是否会经常使用get和set进行赋值场景，比如：接收参数paramVo对象，然后将参数赋值给另外一个对象 public void saveParam(ParamVo vo){ //为了证明ParamVo意义，验证确认密码 if(!vo.getConfirmPassword().equals(vo.getPassword())){ Sy
游戏设计模式-原型模式
qq_38815038的博客
04-14 3357
使用特定原型实例来创建特定种类的对象，并且通过拷贝原型来创建新的对象。 原型模式的核心思想是：一个对象可以生成与自身相似的其他对象。假设我们有一个怪物的类，我们可以这样构造： #include <iostream> class Enemy { public: virtual ~Enemy() {} virtual std::shared_ptr<Enemy> Clone() = 0; }; class BirdEnemy :public Enemy { public.
参考文档-23种JAVA设计模式和15种J2EE设计模式.zip
03-28
Java设计模式是软件开发中的重要概念，它们是解决常见编程问题的经验总结，为代码复用、模块解耦、系统扩展提供了指导原则...对于初学者和有经验的开发者来说，深入理解并实践这些设计模式都是提升技术水平的重要途径。
设计模式-创建型模式、结构型模式和行为型模式
最新发布
03-21
- **应用场景**：当需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作“污染”这些对象的类时。 - **优点**：分离了数据结构和作用于结构上的操作。 10. **中介者模式**： - **...
Java-设计模式.zip
06-15
在编程领域，设计模式是一种被广泛认可的解决常见问题的最佳实践。Java设计模式是Java开发者在构建可维护、可扩展和高效软件时所遵循的一种框架。这个“Java-设计模式.zip”压缩包很可能是包含一系列关于Java设计...
被说了很多遍的设计模式---备忘录模式
y-yg的博客
02-10 1454
[把你的理性思维慢慢变成条件反射] 好久不见，新年第一更，本文，我们讲介绍备忘录模式，文章主题结构与上文一致。惯例，先来看看我们示例工程的环境： 操作系统：win7 x64 其他软件：eclipse mars，jdk7 --------------------------------------------------------------------
被说了很多遍的设计模式---抽象工厂模式
y-yg的博客
11-03 1301
[把你的理性思维慢慢变成条件反射] 本文，我们讲介绍抽象工厂模式，文章主题结构与上文一致。惯例，先来看看我们示例工程的环境： 操作系统：win7 x64 其他软件：eclipse mars，jdk7 ------------------------------------------------------------------------------
被说了很多遍的设计模式---桥接模式
y-yg的博客
02-19 1279
[把你的理性思维慢慢变成条件反射] 本文，我们讲介绍桥接模式，文章主题结构与上文一致。惯例，先来看看我们示例工程的环境： 操作系统：win7 x64 其他软件：eclipse mars，jdk8 --------------------------------------------------------------------------------
被说了很多遍的设计模式---装饰模式
y-yg的博客
10-17 1261
[把你的理性思维慢慢变成条件反射] 本文，我们讲介绍策略模式，文章主题结构与上位一致。惯例，先来看看我们示例工程的环境： 操作系统：win7 x64 其他软件：eclipse mars，jdk7 ------------------------------------------------------------------------------------
设计模式在Android开发中的应用-迭代器模式
如Android SDK对外提供的很多系统服务接口。 - **享元模式（Flyweight）**：有效支持大量细粒度的对象，减少内存使用。在Android中，Bitmap对象的池化就是享元模式的应用。 - **代理模式（Proxy）**：为其他对象...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值