设计模式（五）：原型模式

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

原型模式的目的：解决创建重复对象的问题。

原型模式的原理：Java中Object类是所有类的根类，Object类提供了一个clone()方法，该方法可以将一个Java对象复制。但是需要实现clone的Java类必须实现Cloneable接口，该接口表示该类能够且具有复制的能力。

  1. 传统方式
    我们知道如果有一个对象A a，要想获取一个和a相同的对象，需要新建一个A b = new A(); 并且将a中的内容逐一传给b。而不能直接用A b = a; 因为在java中这样只是引用传递，并没有真正复制一个新的对象出来。

    public class Demo
{
	static class Person
	{
    	int id;
    	int age;
    	String sex;

    	public Person(int id, int age, String sex)
    	{
        	super();
        	this.id = id;
        	this.age = age;
        	this.sex = sex;
    	}

    	@Override
    	public String toString()
    	{
        	return "Person [id=" + id + ", age=" + age + ", sex=" + sex + "]";
    	}
	}

	public static void main(String[] args)
	{
    	Person person1 = new Person(1, 27, "male");
    	Person person2 = person1;   // 错误的拷贝方式，只是引用传递
    	Person person3 = new Person(person1.id, person1.age, person1.sex);

    	System.out.println("person1: " + person1.toString() + " hashCode:"
            	+ person1.hashCode());
    	System.out.println("person2: " + person2.toString() + " hashCode:"
            	+ person2.hashCode());
    	System.out.println("person3: " + person3.toString() + " hashCode:"
            	+ person3.hashCode());
	}
}

    运行结果为：

    person1: Person [id=1, age=27, sex=male] hashCode:118352462
person2: Person [id=1, age=27, sex=male] hashCode:118352462
person3: Person [id=1, age=27, sex=male] hashCode:1550089733

    我们可以看到这种方式，需要代码获取原对象的属性，才能创建新的对象。如果原对象比较复杂，那么这个过程将会痛苦而漫长。如果原对象类的属性有所修改，那么采用这种方式拷贝的代码也都需要修改。这就需要我们的原型模式。

  2. 原型模式（默认为浅拷贝）
    Person类实现Cloneable接口，并重载clone()方法。在复制对象时，只需要调用该对象的clone()方法即可。

    public class PrototypeDemo
{
	static class Person implements Cloneable
	{
    	int id;
    	int age;
    	String sex;

    	public Person(int id, int age, String sex)
    	{
        	super();
        	this.id = id;
        	this.age = age;
        	this.sex = sex;
    	}

    	@Override
    	public String toString()
    	{
        	return "Person [id=" + id + ", age=" + age + ", sex=" + sex + "]";
    	}

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

	public static void main(String[] args)
	{
    	Person person1 = new Person(1, 27, "male");
    	System.out.println("person1: " + person1.toString() + " hashCode:"
            	+ person1.hashCode());
    	try
    	{
        	Person person2 = (Person) person1.clone();		// 对象拷贝
        	System.out.println("person2: " + person2.toString() + " hashCode:"
                	+ person2.hashCode());
    	}
    	catch (CloneNotSupportedException e)
    	{
        	e.printStackTrace();
    	}
	}
}

    运行结果：

    person1: Person [id=1, age=27, sex=male] hashCode:118352462
person2: Person [id=1, age=27, sex=male] hashCode:1550089733

    该方法即为原型模式，对象拷贝方式简单，并且无论原对象的类属性是否变化，只需调用clone()方法，即可完成对象拷贝。但是该方式默认为浅拷贝，对于数据类型是基本类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象；对于数据类型是引用的成员变量，比如成员变量是其它的类对象，那么浅拷贝只能进行引用传递，也就是把该成员变量的引用值复制给新的对象，但两者实际上还是指向同一个实例。（关于浅拷贝和深拷贝，如有需求，需另找资料进行学习）。如果需要深拷贝，也就是对于数据类型是引用的成员变量，也都把引用的实例复制给新的对象，那么需要第3步实现。

  3. 深拷贝
    为验证原型模式为浅拷贝，修改原型模式代码，在Person中添加引用数据类型的成员变量friend。

    public class PrototypeDemo
{
	static class Person implements Cloneable
	{
    	int id;
    	int age;
    	String sex;
    	Person friend;

    	public Person(int id, int age, String sex)
    	{
        	super();
        	this.id = id;
        	this.age = age;
        	this.sex = sex;
    	}

    	@Override
    	public String toString()
    	{
        	return "Person [id=" + id + ", age=" + age + ", sex=" + sex
                	+ ", friend.hashCode=" + friend.hashCode() + "]";
    	}

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

	public static void main(String[] args)
	{
    	Person person1 = new Person(1, 27, "male");
    	person1.friend = new Person(2, 27, "female");
    	System.out.println("person1: " + person1.toString() + " hashCode:"
            	+ person1.hashCode());
    	try
    	{
        	Person person2 = (Person) person1.clone();
        	System.out.println("person2: " + person2.toString() + " hashCode:"
                	+ person2.hashCode());
    	}
    	catch (CloneNotSupportedException e)
    	{
        	e.printStackTrace();
    	}
	}
}

    运行结果：

    person1: Person [id=1, age=27, sex=male, friend.hashCode=118352462] hashCode:1550089733
person2: Person [id=1, age=27, sex=male, friend.hashCode=118352462] hashCode:865113938

    我们可以看到person1和person2的hashCode不同，确实是两个对象，但是他们的friend.hashCode相同，说明在person1的拷贝过程中，person1的friend只是将其引用给了person2的friend，所以他俩还是指向了一个对象。深拷贝就是为了让person1.friend复制一个新的对象给person2.friend。
    实现深拷贝有两种方式，第一种方式是在clone()方法中添加代码实现类中对象的拷贝，第二种方式通过序列化和反序列化来实现深拷贝。我理解第二种方式不能叫做原型模式吧？下面通过示例说明

    1. 重写clone()方法
      @Override
protected Object clone() throws CloneNotSupportedException
{
    Person personClone = (Person)super.clone();
    if (friend != null)
    {
        personClone.friend = (Person)friend.clone();
    }
    return personClone;
}
      这里只粘贴部分代码，因为我不舍得重新写代码，friend.clone()调用的还是这个函数，所以有一个递归，如果这里的friend还有friend，就会接着往下走。运行结果如下：
      person1: Person [id=1, age=27, sex=male, friend.hashCode=118352462] hashCode:1550089733
person2: Person [id=1, age=27, sex=male, friend.hashCode=865113938] hashCode:1442407170
      搞定！
    2. 通过序列化和反序列化来实现
      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 DeepCloneDemo
{
	static class Person implements Serializable
	{
		/**
 		* generated serial version ID
 		*/
		private static final long serialVersionUID = 9079128548395795470L;
		
		int id;
		int age;
		String sex;
		Person friend;

		public Person(int id, int age, String sex)
		{
    		super();
    		this.id = id;
    		this.age = age;
    		this.sex = sex;
		}

		@Override
		public String toString()
		{
    		return "Person [id=" + id + ", age=" + age + ", sex=" + sex
            		+ ", friend.hashCode=" + friend.hashCode() + "]";
		}

		public Object deepClone() throws IOException, ClassNotFoundException
		{
    		// 序列化操作
    		ByteArrayOutputStream bos = new ByteArrayOutputStream();
    		ObjectOutputStream oos = new ObjectOutputStream(bos);
    		oos.writeObject(this);
    		oos.flush();
    
    		// 反序列化操作
    		ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
    		ObjectInputStream ois = new ObjectInputStream(bis);
    		Person personClone = (Person)ois.readObject();
    
    		return personClone;
		}
	}

	public static void main(String[] args)
	{
		Person person1 = new Person(1, 27, "male");
		person1.friend = new Person(2, 27, "female");
		System.out.println("person1: " + person1.toString() + " hashCode:"
        		+ person1.hashCode());
		try
		{
    		Person person2 = (Person) person1.deepClone();
    		System.out.println("person2: " + person2.toString() + " hashCode:"
            		+ person2.hashCode());
		}
		catch (ClassNotFoundException e)
		{
    		e.printStackTrace();
		}
		catch (IOException e)
		{
    		e.printStackTrace();
		}
	}
}
      运行结果：
      person1: Person [id=1, age=27, sex=male, friend.hashCode=118352462] hashCode:1550089733
person2: Person [id=1, age=27, sex=male, friend.hashCode=1831932724] hashCode:1747585824
      搞定，收工！对于序列化的了解不足，就不先在这多解释了。
ItsWalter
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言：原型模式及举例
03-07
原型模式（Prototype Pattern）是一种创建型设计模式，它允许通过复制已有对象来创建新对象，而无需知道具体创建过程。在C语言中，由于没有内置的克隆机制，我们需要自定义函数来实现对象的复制。这一模式常用于减少...
ava常用设计模式-原型模式
08-26
ava常用设计模式-原型模式 原型模式（Prototype Pattern）是一种创建型设计模式，允许通过复制现有对象来创建新对象，而不是通过实例化类来创建新对象。在需要创建大量相似对象时非常有用，它可以避免重复创建对象...
设计模式之原型模式（Prototype Design Pattern）
xjj1314的专栏
01-27 216
原型模式，可以理解为克隆模式，就是对一个已创建的对象进行克隆。这个对象必须提供克隆的方法。 我们先看一个简单的例子： //实现Cloneable ，重写clone方法，使用对象提供克隆的能力 public class Article implements Cloneable { public Article(){ System.out.println("初始化"); } public Article clone() { System.out.
浅析java设计模式之原型模式
qq_34459728的博客
09-11 117
原型模式 描述： 原型模式的主要目的是在需要频繁创建重复的对象的时候，针对一个源对象，创建这个源对象的克隆对象。特别是在创建复杂对象时保证了性能。 常用场景： 在创建很复杂，或者创建对象时消耗贼大的场景中可以使用原型模式。 比如创建对象时需要大量的sql语句去赋值，这时，为了避免数据库IO，内存和cpu的消耗就可以使用原型模式。 项目结构： 实现： 1.创建一个实现了Cloneable类的抽象类Mycloth /** * @author Carl * @version 1.0 * @date 202
原型模式的作用和意义
huangyimo的专栏
05-21 8778
一、原型模式的作用？ 1、基本就是你需要从A的实例得到一份与A内容相同，但是又互不干扰的实例的话，就需要使用原型模式。 2、用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。这个其实和C++的拷贝构造函数的作用是相似的（但不相同），实际上就是动态抽取 当前对象 运行时 的 状态。 3、当然有的时候，如果我们并不需要基于现有的对象复制新的对象，或者我们需要的就是一个干净的空对象，...
C++设计模式：原型模式
ajbb093的博客
04-07 1026
在本案例中，如果对史莱姆的原型进行克隆，也就是分裂成不同的对象，而不同的史莱姆型号会对应着不同的技能，假设大型史莱姆是撞击，普通史莱姆是喷射，小型史莱姆是自爆，则简单地进行深克隆以及浅克隆可能会引起异常。因此，对此的解决办法便是原型模式结合状态模式使用，状态模式是指在软件构建过程中，某些对象的状态如果发生改变，其行为也会随之发生变化，使用状态模式将能允许一个对象在其内部状态发生改变时改变它的行为，从而使对象看起来似乎修改了其行为。，普通史莱姆转换成小型史莱姆，其中四只转换后的小型史莱姆共享血量（
详解设计模式：原型模式
栗筝i的博客
11-28 3058
原型模式（Prototype Pattern） ，是 GoF 的 23 种设计模式的一种，是用于创建重复的对象，同时又能保证性能。属于创建型模式，提供创建对象的最佳方式。 原型（Prototype），在制造业中通常是指大批量生产开始之前研发出的概念模型，并基于各种参数指标对其进行检验，如果达到了质量要求，即可参照这个原型进行批量生产。 本篇内容包括：关于原型模式、原型模式-浅拷贝实现、原型模式-深拷贝实现
设计模式：原型模式
李白
01-03 873
原型模式（Prototype Pattern）是一种创建型设计模式，它允许通过复制现有的对象来创建新对象，而无需从头开始编写代码。在这个模式中，我们可以使用已经存在的对象作为“原型”，并通过克隆该原型对象创建一个新的对象，而不是从头开始构建一个新对象。该模式的核心思想是将对象的创建过程与使用过程分离，通过复制已有对象来减少对象的创建过程，从而提高系统的性能和效率。
JAVA设计模式之原型模式详解
励志成为一名优秀的全能型软件开发工程师。
02-05 3479
定义: 原型模式(Prototype Design Pattern)用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。西游记中的孙悟空 拔毛变小猴,孙悟空这种根据自己的形状复制出多个身外化身的技巧,在面向对象软件设计领域被称为原型模式.孙悟空就是原型对象.原型模式主要解决的问题。
Java设计模式之创建型：原型模式
热门推荐
张维鹏的博客
11-01 1万+
原型模式主要用于对象的创建，使用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。原型模式比 new 方式创建对象的性能要好的多，因为 Object 类的 clone() 方法是一个本地方法，直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显；并且可以简化对象的创建；
Java 设计模式——原型模式
代码星辰的博客
07-22 1163
本文介绍了原型模式的相关知识。
java设计模式之原型模式
m0_47944994的博客
11-16 3804
java设计模式之原型模式
设计模式之原型模式.docx
09-28
【设计模式之原型模式】 设计模式是软件工程中的一种最佳实践，是对在特定上下文中反复出现的软件设计问题的解决方案。原型模式属于对象创建型模式，它的主要思想是通过复制已有对象来创建新对象，降低了类的实例化...
Java设计模式-原型模式详解
11-24
Java 设计模式 - 原型模式详解 原型模式是 Java 设计模式之一，它用于创建对象时，指定创建对象的类型，并通过拷贝这些原型创建新的对象。该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原...
Python 程序语言设计模式思路-创建型模式：原型模式：通过复制现有对象来创建新对象，面向对象编程
05-21
原型模式（Prototype Pattern）作为创建型模式的一种，通过复制现有对象来创建新对象，从而避免了使用构造函数直接实例化对象的过程。
第六天：java设计模式、GUI编程与面向对象设计原则
最新发布
JavaUpgrade
08-13 226
设计模式的定义：回顾设计模式的定义，即解决特定设计问题的通用解决方案。常见设计模式：了解并掌握几种常见的设计模式，如单例模式、工厂模式、策略模式、观察者模式等。了解它们的基本结构、应用场景和优缺点。设计模式的应用：通过实际例子或练习，尝试将设计模式应用到Java代码中，以解决实际问题。
【1】设计模式简介
2201_75414908的博客
08-12 164
设计模式简介
C++ | 深入理解C++中的特殊类设计和单例模式(懒汉模式、饿汉模式)
LiHongyu05的博客
08-12 451
在C++编程中，类的设计往往需要满足特定的需求和约束。特殊类设计模式提供了一种方法来实现这些需求，确保类的使用既安全又高效。本文将探讨几种常见的特殊类设计方式，包括不可拷贝类、只能在堆上创建对象的类、只能在栈上创建对象的类、不可继承的类以及单例模式。
面试实战题-其他知识（设计模式）
sinat_27143551的博客
08-12 424
采用多种decoder/encoder 支持，对TCP粘包/分包进行自动化处理 可使用接受/处理线程池，提高连接效率，对重连、心跳检测的简单支持 可配置IO线程数、TCP参数， TCP接收和发送缓冲区使用直接内存代替堆内存，通过内存池的方式循环利用ByteBuf 通过引用计数器及时申请释放不再引用的对象，降低了GC频率 使用单线程串行化的方式，高效的Reactor线程模型 大量使用了volitale、使用了CAS和原子类、线程安全类的使用、读写锁的使用。● 连接的建立是经过三次握手，断开的时候四次挥手。
软件设计模式详解：原型模式与设计原则
"该资源是一份关于原型模式的PPT，由哈尔滨工业大学计算机学院的唐好选教授制作，主要探讨了软件设计模式，特别是原型模式的结构。内容涵盖了设计模式的基础知识、创建型模式、结构型模式和行为型模式，阐述了设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值