设计模式之原型模式

已于 2023-05-18 14:45:49 修改
阅读量183 收藏
点赞数
分类专栏： Java设计模式 文章标签： 原型模式 设计模式
于 2020-11-08 22:23:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang_luwei/article/details/109566236
版权

文章目录

原型模式的介绍

原型模式我们也称为克隆模式，即根据某个对象为原型克隆出来一个一模一样的对象，该对象的属性和原型对象一模一样。而且对于原型对象没有任何影响。原型模式的克隆方式有两种：浅克隆和深度克隆：

  • 浅克隆：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，（浅克隆）浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。 Object类提供的方法clone只是拷贝本对象 ， 其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址。看下图：v1（原型对象），v2（v2是由v1克隆出来的）里面的一个引用类型的变量是指向的同一块内存地址，要修改这个变量的话，v1，v2都会被改动

    在这里插入图片描述

  • 深克隆：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。看下图：通过v1克隆v2时，把里面的变量属性也克隆了一份，并分配了内存空间。

在这里插入图片描述

运用场景

如果需要短时间创建大量对象的情况下，原型模式就是我们可以考虑实现的方式。
因为在Java中通过new关键字创建的对象是非常繁琐的(类加载判断，内存分配，初始化等)，这就意味着这个过程是很耗费资源与时间的。下面也有两者的对比。

原型模式之浅克隆

package com.wlw.prototype.qianCopydemo01;

import java.util.Date;

/*
原型模式的实现，就是依靠克隆，先创建出一个对象v1，通过v1 克隆出 v2
实现克隆：
    1.实现接口Cloneable
    2.重写clone()方法
 */
//视频类
public class Video implements Cloneable {
    private String name;
    private Date date;

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

    public Video() {
    }

    public Video(String name, Date date) {
        this.name = name;
        this.date = date;
    }

    //get set toString 省略.....
}


package com.wlw.prototype.qianCopydemo01;

import java.util.Date;

public class BiliBili {
    public static void main(String[] args) throws CloneNotSupportedException {
        Date date = new Date();
        //创建原型对象v1
        Video v1 = new Video("java",date);
        System.out.println("v1=>"+v1);
        System.out.println("v1.hashcode=>"+v1.hashCode());

        //通过v1 克隆出 v2 (v2和v1是完全一样的，除了hashCode，因为v2也是一个新的对象)
        Video v2 = (Video)v1.clone();
        System.out.println("v2=>"+v2);
        System.out.println("v2.hashcode=>"+v2.hashCode());
    }
}
/*
v1=>Video{name='java', date=Tue Oct 20 15:41:25 CST 2020}
v1.hashcode=>21685669
v2=>Video{name='java', date=Tue Oct 20 15:41:25 CST 2020}
v2.hashcode=>2133927002
*/
  • 看一下浅克隆的问题：虽然产生了两个完全不同的对象，但是被复制的对象里的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。
  • 看下面的例子，v2是由v1复制出来的，而Video类里有个Date类型的变量，此时v1与v2这两个对象里的Date类型的变量是同一个，改变一个，另一个也会跟着改变。
package com.wlw.prototype.qianCopydemo01;

import java.util.Date;

public class BiliBili {
    public static void main(String[] args) throws CloneNotSupportedException {
        Date date = new Date();
        //创建原型对象v1
        Video v1 = new Video("java",date);
        //通过v1 克隆出 v2 (v2和v1是完全一样的，除了hashCode，因为v2也是一个新的对象)
        Video v2 = (Video)v1.clone();

        System.out.println("v1=>"+v1);
        System.out.println("v2=>"+v2);
        System.out.println("=========================");
        date.setTime(22135321);
        System.out.println("v1=>"+v1);
        System.out.println("v2=>"+v2);
    }
}
/*
v1=>Video{name='java', date=Tue Oct 20 15:45:59 CST 2020}
v2=>Video{name='java', date=Tue Oct 20 15:45:59 CST 2020}
=========================
v1=>Video{name='java', date=Thu Jan 01 14:08:55 CST 1970}
v2=>Video{name='java', date=Thu Jan 01 14:08:55 CST 1970}
date更新之后，v1，v2里面的date全都更新了，这就是v1，v2指向了同一个date
*/

原型模式之深克隆

实现深克隆，有三种途径：

  1. 让每个引用类型属性内部都重写clone() 方法
  2. 使用序列化流
  3. 使用开源工具类（本质上和第二种是一样的，都是通过序列化）

这里实现深克隆使用的方式是：让每个引用类型属性内部都重写clone()方法。
另外两种可参考：java中赋值语句（=）与浅拷贝与深拷贝弄出来的对象有什么区别

package com.wlw.prototype.shenCopydemo02;

import java.util.Date;

/*
原型模式的实现，就是依靠克隆，先创建出一个对象v1，通过v1 克隆出 v2
实现浅克隆：
    1.实现接口Cloneable
    2.重写clone()方法
而要实现深克隆，有三种方式：
	1.让每个引用类型属性内部都重写clone() 方法
	2.使用序列化流
	3.使用开源工具类	
	
这里使用的是第一种方式：让每个引用类型属性内部都重写clone()方法
 */
//视频类
public class Video implements Cloneable {
    private String name;
    private Date date;

    //深克隆
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();
        //深克隆
        Video v = (Video) obj;
        v.date = (Date)this.getDate().clone();//把对象的属性也克隆一份

        return obj;
    }

    public Video() {
    }

    public Video(String name, Date date) {
        this.name = name;
        this.date = date;
    }

    //get set toString 省略.....
}


package com.wlw.prototype.shenCopydemo02;

import java.util.Date;

public class BiliBili {
    public static void main(String[] args) throws CloneNotSupportedException {
        Date date = new Date();
        //创建原型对象v1
        Video v1 = new Video("java",date);
        //通过v1 克隆出 v2 (v2和v1是完全一样的，除了hashCode，因为v2也是一个新的对象)
        Video v2 = (Video)v1.clone();

        System.out.println("v1=>"+v1);
        System.out.println("v2=>"+v2);
        System.out.println("=========================");
        date.setTime(22135321);
        System.out.println("v1=>"+v1);
        System.out.println("v2=>"+v2);
    }
}
/*
v1=>Video{name='java', date=Tue Oct 20 18:18:59 CST 2020}
v2=>Video{name='java', date=Tue Oct 20 18:18:59 CST 2020}
=========================
v1=>Video{name='java', date=Thu Jan 01 14:08:55 CST 1970}
v2=>Video{name='java', date=Tue Oct 20 18:18:59 CST 2020}
只有v1的时间改变了，v2的时间并没有改变
*/

原型模式和直接new对象方式的比较

当我们需要大量的同一类型对象的时候可以使用原型模式，下面是两种方式的性能对比:

用两种方式同时生成10个对象：

/**
 * 测试普通new方式创建对象和clone方式创建对象的效率差异！
 * 如果需要短时间创建大量对象，并且new的过程比较耗时。则可以考虑使用原型模式！
 */
public class Test {
	
	public static void testNew(int size){
		long start = System.currentTimeMillis();
		for(int i=0;i<size;i++){
			User t = new User();
		}
		long end = System.currentTimeMillis();
		System.out.println("new的方式创建耗时："+(end-start));
	}
	
	public static void testClone(int size) throws CloneNotSupportedException{
		long start = System.currentTimeMillis();
		User t = new User();
		for(int i=0;i<size;i++){
			User temp = (User) t.clone();
		}
		long end = System.currentTimeMillis();
		System.out.println("clone的方式创建耗时："+(end-start));
	}
	
	
	public static void main(String[] args) throws Exception {	
		testNew(10);
		testClone(10);
	}
}


//用户类
class User implements Cloneable {  
	public User() {
		try {
      //模拟创建对象耗时的过程!
			Thread.sleep(10);  
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
    // 直接调用object对象的clone()方法！
		Object obj = super.clone();  
		return obj;
	}
}

/*
输出结果：
new的方式创建耗时：108
clone的方式创建耗时：11
*/

用两种方式同时生成1000个对象：

/**
 * 测试普通new方式创建对象和clone方式创建对象的效率差异！
 * 如果需要短时间创建大量对象，并且new的过程比较耗时。则可以考虑使用原型模式！
 */
public class Test {
	
	public static void testNew(int size){
		long start = System.currentTimeMillis();
		for(int i=0;i<size;i++){
			User t = new User();
		}
		long end = System.currentTimeMillis();
		System.out.println("new的方式创建耗时："+(end-start));
	}
	
	public static void testClone(int size) throws CloneNotSupportedException{
		long start = System.currentTimeMillis();
		User t = new User();
		for(int i=0;i<size;i++){
			User temp = (User) t.clone();
		}
		long end = System.currentTimeMillis();
		System.out.println("clone的方式创建耗时："+(end-start));
	}
	
	
	public static void main(String[] args) throws Exception {	
		testNew(1000);
		testClone(1000);
	}
}

/*
new的方式创建耗时：10836
clone的方式创建耗时：11
*/

小结：在短时间创建大量对象的情况下， 通过clone的方式性能开销基本没有什么影响，而new的方式随着实例的对象越来越多，性能会急剧下降。

开发中的应用场景

原型模式很少单独出现，一般是和工厂方法模式一起出现，通过clone的方法创建一个对象，然后由工厂方法提供给调用者。

在spring中bean的创建实际就是两种：单例模式和原型模式。在此看出原型模式一般是和工厂模式搭配起来一起使用。

悬浮海
关注
专栏目录
串口框架V1和V2版本对比
rtthreadiotos的博客
07-28 1461
本文由RT-Thread官方论坛用户123原创发布：https://club.rt-thread.org/ask/article/2915.html 串口框架V1和V2版本对比 V1版本串口框架（以及驱动）总结 这部分的总结，其实也是在之前写的串口V1版本的文章中有所提及的，这里大致再总结一下，如果初次查看的话，可能会造成一些困扰，那么就去请先去查看之前的三篇文章：串口(一)、 串口(二) 、串口(三)相信看完之后会更加清晰一些。另外如果有任何描述不当或者分析不对的地方，尽情评论区发言或者直接私信我。
c++-设计模式之原型模式（Prototype Pattern）
最新发布
09-18
原型模式（Prototype Pattern）是一种创建型设计模式，允许通过复制现有对象来创建新对象，而不是通过类构造器。这种模式常用于需要频繁创建相似对象的场景，能够提高性能并减少内存使用。 原型模式的组成 原型接口...
如何更优雅管理API接口版本（v1/v2/v3…）
追风2019
04-24 2万+
一、前言 一个web项目中，随着需求的变更或增加，API接口也会跟着变化，而如果APP发布后，已使用的接口肯定不能直接覆盖更新，需要新增升级版本接口和新的APP版本对应，因此多个版本接口更替后，如何更优雅管理不同版本接口代码，如何设计更直观的接口文档呈现给app端，这是我们后端工程师需要考虑的事情，下面总结接口版本管理经验。 二、接口代码版本规范 考虑到接口今后一定会进行版本迭代，因此一开始...
java设计模式之原型模式
尼古拉斯大树的博客
01-03 1365
java设计模式之原型模式简单介绍和代码demo
C++设计模式：原型模式
ajbb093的博客
04-07 1128
在本案例中，如果对史莱姆的原型进行克隆，也就是分裂成不同的对象，而不同的史莱姆型号会对应着不同的技能，假设大型史莱姆是撞击，普通史莱姆是喷射，小型史莱姆是自爆，则简单地进行深克隆以及浅克隆可能会引起异常。因此，对此的解决办法便是原型模式结合状态模式使用，状态模式是指在软件构建过程中，某些对象的状态如果发生改变，其行为也会随之发生变化，使用状态模式将能允许一个对象在其内部状态发生改变时改变它的行为，从而使对象看起来似乎修改了其行为。，普通史莱姆转换成小型史莱姆，其中四只转换后的小型史莱姆共享血量（
设计模式23模式介绍
热门推荐
学Java，找哪吒
01-18 13万+
设计模式精品专栏。
设计模式创建型模式之原型模式
针线犹存未忍开
08-29 1296
原型模式是一种创建型设计模式，用于创建对象的克隆。它通过复制现有对象的原型来创建新的对象，而无需通过实例化类来创建对象。原型模式的实现通常需要实现Cloneable接口，并重写clone()方法来进行对象的复制。
JAVA设计模式之原型模式
u012957549的博客
05-19 2725
定义：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。 类型：创建类模式 类图： 原型模式主要用于对象的复制，它的核心是就是类图中的原型类Prototype。Prototype类需要具备以下两个条件： 实现Cloneable接口。在java语言有一个Cloneable接口，它的作用只有一个，就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java...
软件设计模式之原型模式
qq_45726327的博客
06-19 1225
原型模式(Prototype Pattern)的简单程度仅次于单例模式和迭代器模式。正是由于简单，使用的场景才非常地多，其定义如下:Specify the kinds of objects to create using a prototypical instance, and create new objects by copyingthis prototype.(用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
设计模式之原型模式.docx
09-28
【设计模式之原型模式】 设计模式是软件工程中的一种最佳实践，是对在特定上下文中反复出现的软件设计问题的解决方案。原型模式属于对象创建型模式，它的主要思想是通过复制已有对象来创建新对象，降低了类的实例化...
C++设计模式之原型模式
12-25
在GOF的《设计模式：可复用面向对象软件的基础》中是这样说的：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。这这个定义中，最重要的一个词是“拷贝”，也就是口头上的复制，而这个拷贝，也...
Android编程设计模式之原型模式实例详解
01-20
【Android编程设计模式之原型模式实例详解】 原型模式是一种创建型设计模式，它允许通过复制现有的对象来创建新对象，从而提高程序的性能。在Android开发中，原型模式尤其适用于那些初始化过程复杂或耗时的对象，...
Unity设计模式——原型模式
羽阿呆的博客
10-08 1140
由于克隆实在太常用，.Net在System命名空间提供了IClone接口，唯一的Clone()方法，只要实现这个接口就可以完成原型模式了。现实设计当中，一般会再有一个“工作经历”类，当中有“时间区间”和“公司名称”等属性，“简历”类直接调用。对于引用类型，克隆后没有实现真正的克隆，而是只克隆了引用地址，这叫做“然后修改简历类，新增构造函数，方便克隆工作经历类，再修改简历类的克隆方法。把引用对象的变量指向复制过的新对象，而不是原有的被引用的对象。而所有的对其他对象的引用都仍然指向原来的对象。
设计模式之工厂模式（简单工厂、工厂方法、抽象工厂）
wang_luwei的博客
11-08 2012
工厂模式 工厂模式的作用：实现了创建者和调用者的分离 核心本质： 实例化对象不使用new，用工厂方法代替 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦 详细分类： 简单（静态）工厂模式：用来生产同一等级结构中的任意产品(对于增加新的产品，需要修改已有代码) 工厂方法模式：用来生产同一等级结构中的固定产品(支持增加任意产品) 抽象工厂模式：围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。 满足OOP七大原则中的三个： 开闭原则： 一个软件的实体应当对扩展开
设计模式之观察者模式相关、监听器模式
wang_luwei的博客
06-15 1736
观察者模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象的状态发生变化时，会通知所有观察者对象，使它们能够自己更新自己。（在对象之间定义了一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象会收到通知并自动更新） 观察者模式结构图：Subject类，可以翻译为主题或者抽象通知者，一般用一个抽象类或者一个接口实现。它把所有对观察者对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加、删除观察者对象 以及通知聚集里面的观察者。Con
设计模式之模版方法模式与策略模式
wang_luwei的博客
03-25 1541
模版方法模式、策略模式、简单工厂模式
设计模式之禅：深入解析原型模式
"设计模式之禅之 原型模式" 设计模式是软件工程中的一种经验总结，用于解决常见的设计问题。原型模式是其中的一种，它允许通过复制已有对象来创建新对象，而不是每次都去创建一个新的实例。这种模式在需要大量创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

悬浮海

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值