23种设计模式之原型模式

最新推荐文章于 2024-01-02 12:32:55 发布
最新推荐文章于 2024-01-02 12:32:55 发布
阅读量102 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java 面试 编程语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/space_qi/article/details/112532154
版权

23种设计模式之原型模式

文章目录

参考资料

下文如有错漏之处，敬请指正

一、简介

定义

通过克隆原型的实例对象，创建新的对象。

原理

原型实例实现Cloneable接口（来标示该对象是可克隆的）并重写clone()方法，通过 原型对象.clone() 方法创建新对象。

特点

  • 原型模式是一种创建型设计模式

  • 使用克隆创建的对象不会调用构造函数

  • 对于重量级的对象使用clone比new效率更高

优点

  • 性能优良

    原型模式是基于内存二进制流的拷贝，要比直接new一个对象性能好很多，特别是要在一个循环体内产生大量的对象时，原型模式可以更好地体现其优点。

缺点

  • 逃避构造函数的约束

    由于原型模式是直接在内存中拷贝，因此构造函数不会被执行，减少了约束，可以通过原型模式破坏单例模式。

通用类图

在这里插入图片描述

  • Client：客户端对象，通过Prototype对象的clone方法，创建新的对象
  • Prototype：原型对象，实现Cloneable接口进行克隆标示并重写clone()方法

应用场景

  • 资源优化场景

    创建新对象成本较大，如类初始化需要占用较长的时间、占用太多的CPU资源或网络资源，新的对象可以使用原型模式获得。

  • 性能和安全要求的场景

    通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。

  • 保存对象状态

    如果系统要保存对象的状态，而对象的状态变化很小，或者对象本身占用内存较少时，可以使用原型模式配合备忘录模式来实现。

  • 1个对象对多个修改者

    一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。

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

二、实现分类

浅克隆(浅拷贝)

  • 通过实现Cloneable接口进行克隆标示并重写clone()方法可以实现浅克隆。

  • 在浅克隆中，如果原型对象的属性是值类型，会复制其值；如果属性是引用类型，将复制其引用地址。

  • 注意：

    因为String类型是不可变数据类型，当它的值改变时，它将引用新的值的地址；原引用地址如果有对象引用就保留，否则会被回收。

    如果原型对象修改了String对象，不会影响克隆对象的String对象；反之，克隆对象修改了String对象，也不会影响原型对象的String对象。String字符串详解

    （在此可以将String类型当做值类型）

深克隆(深拷贝)

  • 通过重写clone()方法或对象序列化(Serialization)等方式来实现深克隆。

  • 在深克隆中，无论原型对象的属性是值类型还是引用类型，都将复制一份给克隆对象。

  • 注意：

    • 如果使用重写clone()方法实现深克隆，被克隆的对象需要实现Cloneable接口；

    • 如果使用序列化实现深克隆，被克隆的对象要实现Serializable接口。

浅克隆原型模式

需求：

一个牧羊人可以牧养多只羊，每只羊都大同小异，每只羊只有一个主人。

Prototype：Owner（牧羊人）、Sheep（羊）

Sheep：

package prototype.shallow;


public class Sheep implements Cloneable {
	private String name;

	public Sheep() {

	}

	public Sheep(String name) {
		this.name = name;
	}

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

	public String getName() {
		return name;
	}

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

	@Override
	public String toString() {
		return "Sheep{" +
				"name='" + name + '\'' +
				'}';
	}
}

Owner：

package prototype.shallow;


import java.util.ArrayList;
import java.util.List;

public class Owner implements Cloneable {


	private String name;
	private List<Sheep> sheepList = new ArrayList<>();

	public Owner() {
	}

	public Owner(String name) {
		this.name = name;
	}


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

	public String getName() {
		return name;
	}

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

	public List<Sheep> getSheepName() {
		return sheepList;
	}


	public void setSheepName(Sheep sheep) {
		this.sheepList.add(sheep);
	}


	@Override
	public String toString() {
		return "Owner{" +
				"name='" + name + '\'' +
				", sheepList=" + sheepList +
				'}';
	}
}

Client：

package prototype.shallow;


public class Client {
	public static void main(String[] args) throws CloneNotSupportedException {


		// 原型实例
		Owner owner = new Owner("Space");
		owner.setSheepName(new Sheep("肖恩1号"));

		// 克隆对象
		Owner clone = (Owner) owner.clone();
		clone.setName("Qi");
		clone.setSheepName(new Sheep("肖恩2号"));

		owner.setSheepName(new Sheep("肖恩3号"));


		System.out.println(owner);
		System.out.println(clone);
		/**
		 * 输出结果：
		 * Owner{name='Space', sheepList=[Sheep{name='肖恩1号'}, Sheep{name='肖恩2号'}, Sheep{name='肖恩3号'}]}
		 * Owner{name='Qi', sheepList=[Sheep{name='肖恩1号'}, Sheep{name='肖恩2号'}, Sheep{name='肖恩3号'}]}
		 * 因为是浅克隆，原型实例内部的引用类型的属性只会拷贝引用地址，因此两个Owner的sheepList的值是一样的
		 */

	}
}

深克隆原型模式

1. 重写clone()方法

需求：

一个牧羊人可以牧养多只羊，每只羊都大同小异，每只羊只有一个主人。

Prototype：Owner（牧羊人）、Sheep（羊）

Sheep：

package prototype.deep.Cloneable;

public class Sheep implements Cloneable{
	private String name;

	public Sheep() {

	}

	public Sheep(String name) {
		this.name = name;
	}

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

	public String getName() {
		return name;
	}

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

	@Override
	public String toString() {
		return "Sheep{" +
				"name='" + name + '\'' +
				'}';
	}
}

Owner：

package prototype.deep.Cloneable;

import java.util.ArrayList;
import java.util.List;

public class Owner implements Cloneable {
	private String name;
	private ArrayList<Sheep> sheepList = new ArrayList<>();

	public Owner() {
	}

	public Owner(String name) {
		this.name = name;
	}


	@Override
	protected Owner clone() throws CloneNotSupportedException {
		// 对值类型的克隆
		Owner deep = (Owner) super.clone();
		// 对引用类型的克隆
		List<Sheep> sheepList = new ArrayList<>();
		deep.sheepList = (ArrayList<Sheep>) this.sheepList.clone();
		//返回克隆的对象
		return deep;
	}

	public String getName() {
		return name;
	}

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

	public List<Sheep> getSheepName() {
		return sheepList;
	}


	public void setSheepName(Sheep sheep) {
		this.sheepList.add(sheep);
	}


	@Override
	public String toString() {
		return "Owner{" +
				"name='" + name + '\'' +
				", sheepList=" + sheepList +
				'}';
	}
}

Client：

package prototype.deep.Cloneable;


public class Client {
	public static void main(String[] args) throws CloneNotSupportedException {
		// 原型实例
		Owner owner = new Owner("Space");
		owner.setSheepName(new Sheep("肖恩1号"));

		// 克隆对象
		Owner clone = owner.clone();
		clone.setName("Qi");
		clone.setSheepName(new Sheep("肖恩2号"));

		owner.setSheepName(new Sheep("肖恩3号"));


		System.out.println(owner);
		System.out.println(clone);

		/**
		 * 输出结果：
		 * Owner{name='Space', sheepList=[Sheep{name='肖恩1号'}, Sheep{name='肖恩3号'}]}
		 * Owner{name='Qi', sheepList=[Sheep{name='肖恩1号'}, Sheep{name='肖恩2号'}]}
		 */
	}
}
2. 使用对象的序列化

需求：

一个牧羊人可以牧养多只羊，每只羊都大同小异，每只羊只有一个主人。

Prototype：Owner（牧羊人）、Sheep（羊）

Sheep：

package prototype.deep.serilizable;

import java.io.*;

public class Sheep implements Serializable {
	private String name;

	public Sheep() {

	}

	public Sheep(String name) {
		this.name = name;
	}


	public String getName() {
		return name;
	}

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

	@Override
	public String toString() {
		return "Sheep{" +
				"name='" + name + '\'' +
				'}';
	}
}

Owner：

package prototype.deep.serilizable;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class Owner implements Serializable {

	private String name;
	private List<Sheep> sheepArrayList = new ArrayList<>();

	public Owner() {
	}

	public Owner(String name) {
		this.name = name;
	}


	protected Object deepClone() throws Exception {
		//将对象写入流中
		ByteArrayOutputStream bao = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(bao);
		oos.writeObject(this);

		//将对象从流中取出
		ByteArrayInputStream bis = new ByteArrayInputStream(bao.toByteArray());
		ObjectInputStream ois = new ObjectInputStream(bis);
		
    return (ois.readObject());
	}

	public String getName() {
		return name;
	}

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

	public List<Sheep> getSheepName() {
		return sheepArrayList;
	}


	public void setSheepName(Sheep sheep) {
		this.sheepArrayList.add(sheep);
	}


	@Override
	public String toString() {
		return "Owner{" +
				"name='" + name + '\'' +
				", sheepList=" + sheepArrayList +
				'}';
	}
}

Client：

package prototype.deep.serilizable;

public class Client {
	public static void main(String[] args) throws Exception {

		// 原型实例
		Owner owner = new Owner("Space");
		owner.setSheepName(new Sheep("肖恩1号"));

		// 克隆对象
		Owner clone = (Owner) owner.deepClone();
		clone.setName("Qi");
		clone.setSheepName(new Sheep("肖恩2号"));

		owner.setSheepName(new Sheep("肖恩3号"));


		System.out.println(owner);
		System.out.println(clone);

		/**
		 * 输出结果：
		 * Owner{name='Space', sheepList=[Sheep{name='肖恩1号'}, Sheep{name='肖恩3号'}]}
		 * Owner{name='Qi', sheepList=[Sheep{name='肖恩1号'}, Sheep{name='肖恩2号'}]}
		 */

	}
}

三、总结

  • 原型模式可以通过浅克隆和深克隆两种方式实现
  • 原型模式先产生出一个包含大量共有信息的类，然后拷贝出副本，修正细节信息， 建立了一个完整的个性对象。
你好，琦
关注
专栏目录
23种设计模式（5）：原型模式
java开发指南博客 【转载】
03-26 1242
定义：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。 类型：创建类模式 类图： 原型模式主要用于对象的复制，它的核心是就是类图中的原型类Prototype。Prototype类需要具备以下两个条件： 实现Cloneable接口。在java语言有一个Cloneable接口，它的作用只有一个，就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在jav...
原型模式的类图。
weixin_30725315的博客
11-14 428
用Viso画的UML。 转载于:https://www.cnblogs.com/longdb/p/7834690.html
设计模式--原型模式（附带类关系图一张）
My diary
08-03 838
  using System;using System.Collections.Generic;using System.Text;namespace ConsoleApplication1{    public class Simple:ICloneable     {        private int field1;        private int field2;  
原型设计模式
qq_44392492的博客
08-21 694
原型模式(Prototype模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节
设计模式(五)——原型模式(Prototype Pattern)
Duktig的博客
03-15 345
原型模式 基本介绍 原型模式(Prototype 模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节。 工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即 对象.clone() 通过new产生一个对象需要非常...
C++ 23种设计模式1
08-04
《C++ 23种设计模式1》是关于软件工程中设计模式的深入解析，主要聚焦于C++语言的实现。设计模式是经过时间和实践验证的解决方案，它们针对常见的编程问题提供了一套标准的模板，使得开发者能够更高效地编写可复用、...
23种设计模式整理pdf
07-14
设计模式详解 设计模式是软件开发中的一...在本文中，我们对23种常见的设计模式进行了整理和解释，每种模式都有其优点和缺点，开发者可以根据实际情况选择合适的设计模式，以提高代码的可重用性、可维护性和可扩展性。
C#23种设计模式【完整】.pdf
10-18
本文档详细介绍了23种C#设计模式，包括创建型、结构型和行为型三个大类。这些设计模式是.NET进阶必备的知识，通过学习和掌握这些设计模式，可以提高程序员的设计和编码能力。 创建型设计模式 1. 单件模式...
23种设计模式(C++).pdf
11-29
《设计模式精解－GoF 23 种设计模式解析附 C++实现源码》是一本深入探讨软件设计模式的书籍，它涵盖了创建型、结构型和行为型三种主要类型的23个经典设计模式，并提供了C++语言的实现代码。设计模式是软件工程中的...
Java设计模式之23种设计模式详解
08-18
"Java设计模式之23种设计模式详解" Java设计模式是软件工程的基石，项目中合理的运用设计模式可以完美的解决很多问题。设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计...
几种常见设计模式案例及类图
07-23
这是几种常见设计模式案例及其对应的类图，包括工厂方法模式，抽象工厂模式，单利模式等，用C#编写。
原型模式
今天也要好好学习哟
06-11 608
原型模式介绍   用原型实例指定创建对象的种类，并通过复制这些原型创建新的对象，称为原型模式   原型模式是一个创建型模式,用户可以从一个样板对象中复制出一个内部属性一致的对象,这个过程就是"克隆"。被复制的对象实例就是"原型"，这个原型是可以定制的。 原型模式应用场景 类初始化需要消耗非常多得资源，这个资源包括数据、硬件资源等，通过复制避免这些消耗。 通过new产生一个对象需要非常频繁的数据...
Java设计模式之原型模式最详解（类图+源码）
shaAmerica的博客
06-15 2258
Java设计模式之原型模式最详解（类图+源码）
常用的设计模式之原型模式
焱童鞋
04-20 561
原型模式 原型模式(prototype pattern)是指原型实例创建对象的种类，不使用new关键字来创建对象，而是通过拷贝原型对象来创建对象，属于创建型模式。（一版是基于二进制流的复制） 通用的类图如下： ...
【专题系列】搞定设计模式之—— 十三 ：原型模式
hello world！
08-19 321
点击上方“java大数据修炼之道”，选择“设为星标”优质文章, 第一时间送达目录什么是原型模式？个性化电子账单使用原型模式前使用原型模式后原型模式的优缺点原型模式的优点原型模式的缺点深克...
【设计模式-2】原型模式的原理、代码实现及类图展示
最新发布
qq_35850405的博客
01-02 1269
原型模式也是一种创建型的涉及模式，实现和原理总体比较简单，一句话总结呢，就是可以实现用已有的对象创建新的对象，而不是用类来实例化对象，这样可以起到提升效率的目的。众所周知，类的实例化可以创建对象，但其实这是一个比较耗时耗力的工作，尤其是在大量实例化对象的业务场景下，可能会对系统的性能造成很大的影响。这时候，原型模式就可以很好的解决问题，用已有的对象来生成对象的副本，这里已有的对象就是原型对象，副本对象就是拷贝对象。
Day42-设计模式-原型模式
欢迎来到Liu_zimo的博客
03-15 161
title: Day42-设计模式-原型模式 date: 2021-03-04 18:14:37 author: Liu_zimo 设计模式 设计模式分为三种类型，共23种 创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。 行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式(Interpreter模式)、状态模式、策略模式、职责链模式(责任.
设计模式-原型模式
TJC100_1001_10的博客
03-20 1134
设计模式-原型模式 什么是原型模式 原型模式用于需要重复创建的实例，当我们需要实例时通过封装好的方法获取数据相同但引用“地址”（与单例模式的不同之处）不同的实例
C#版23种设计模式详解：单例模式
“23种设计模式之C#版本.pdf”主要介绍了C#语言中的23种经典设计模式，包括创建型、结构型和行为型模式。这本书以C#语法为载体，深入浅出地讲解了这些模式的动机、意图、适用场景及代码实现。 首先，我们来探讨创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值