原型设计模式

最新推荐文章于 2025-10-06 18:44:04 发布
原创 最新推荐文章于 2025-10-06 18:44:04 发布 · 809 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
设计模式

当前文章被收录于：

设计模式
12 篇文章 0 人学习
订阅专栏 查看详情

Java设计模式 --- 原型设计模式

1、克隆羊问题

1.1 传统方法解决克隆羊问题

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

  • 传统方式解决克隆羊问题
    在这里插入图片描述

public class Client {
    public static void main(String[] args) {
        //传统方法 原型类
        Sheep sheep = new Sheep("多莉", 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());

        System.out.println(sheep);//Sheep{name='多莉', age=1, color='白色'}
        System.out.println(sheep2);//Sheep{name='多莉', age=1, color='白色'}
        System.out.println(sheep3);//Sheep{name='多莉', age=1, color='白色'}

    }
}

//羊
class Sheep{
    private String name;
    private int age;
    private String color;

    public Sheep() {
    }

    public Sheep(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

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

     get/set方法
}

1.2 传统的方式的优缺点

  1. 优点是比较好理解，简单易操作。
  2. 在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂 时，效率较低
  3. 总是需要重新初始化对象，而不是动态地获得对象运行时的状态, 不够灵活
  4. 改进的思路分析

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

2、原型模式

2.1 基本介绍

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

2.2 原型模式原理结构图-uml类图

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

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

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

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

package creat.Prototye.improve;

public class Sheep implements Cloneable{
    private String name;
    private int age;
    private String color;
    public Sheep friend;//引用数据类型

    public Sheep() {
    }

    public Sheep(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    //重写方法 克隆该实例，使用默认的clone方法来完成
    @Override
    protected Object clone(){
        Sheep sheep = null;
        try {
            sheep =(Sheep) super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println(e.getMessage());
        }
        return sheep;
    }

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



public class Client {
    public static void main(String[] args) {
        System.out.println("原型模式完成对象的创建");
        //此时扩展只需要改变原型类的属性，克隆类都相应的改变了
        Sheep sheep = new Sheep("多莉", 1, "白色");
        sheep.friend = new Sheep("小莉",2,"乳白色");

        Sheep sheep2 =(Sheep) sheep.clone();//克隆

        System.out.println("sheep "+sheep +"sheep.friend="+sheep.friend.hashCode());
        System.out.println("sheep2 "+sheep2 +"sheep2.friend="+sheep2.friend.hashCode());
        System.out.println(sheep == sheep2); //false

    }
}

在这里插入图片描述
此时我们发现Object里的默认克隆在处理引用数据类型时，只是对该属性进行了引用复制，实际地址值还是原型对象里分配的那个对象,此时克隆为浅克隆。

.

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

  1. Spring中原型bean的创建，就是原型模式的应用
  2. 代码分析+Debug源码
    在这里插入图片描述

.

3、深入讨论-浅拷贝和深拷贝

3.1 浅拷贝的介绍

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

3.2 深拷贝基本介绍

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

3.3 深拷贝应用实例

3.3.1 使用 重写clone方法实现深拷贝

DeepCloneableTarget 类

//实现序列化和Cloneable接口
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();
	}
}

DeepProtoType类

public class DeepProtoType implements Serializable, Cloneable{
	
	public String name; //String 属性
	public DeepCloneableTarget deepCloneableTarget;//引用数据类型
	public DeepProtoType() {
		super();
	}
	
	

	//深拷贝-方式一 使用clone方法
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Object deep = null;

		//完成对基本数据类型 和String的克隆
		deep = super.clone();

		//对引用数据类型 进行单独处理
		DeepProtoType deepProtoType = (DeepProtoType)deep;
		//deepCloneableTarget克隆一份
		deepProtoType.deepCloneableTarget  = (DeepCloneableTarget)deepCloneableTarget.clone();
		
		// TODO Auto-generated method stub
		return deepProtoType;
	}
	
}

Client 类

public class Client {

	public static void main(String[] args) throws Exception {
	
		DeepProtoType p = new DeepProtoType();
		p.name = "多莉";
		p.deepCloneableTarget = new DeepCloneableTarget("小莉", "LiLi");
		
		//方式一 完成深拷贝
		DeepProtoType p2 = (DeepProtoType) p.clone();

		System.out.println("p.name= " + p.name + "   p.deepCloneableTarget= " + p.deepCloneableTarget.hashCode());
		System.out.println("p2.name= " + p2.name + "  p2.deepCloneableTarget= " + p2.deepCloneableTarget.hashCode());
		//p.name= 多莉 p.deepCloneableTarget= 685325104
		//p2.name= 多莉 p2.deepCloneableTarget= 460141958  引用数据类型地址不一样，实现深拷贝
	}

}

3.3.2 使用序列化来实现深拷贝
在DeepProtoType 里加一个 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();
	}

	//深拷贝-方式一 使用clone方法
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Object deep = null;

		//完成对基本数据类型 和String的克隆
		deep = super.clone();

		//对引用数据类型 进行单独处理
		DeepProtoType deepProtoType = (DeepProtoType)deep;
		//deepCloneableTarget克隆一份
		deepProtoType.deepCloneableTarget  = (DeepCloneableTarget)deepCloneableTarget.clone();
		
		return deepProtoType;
	}
	

	//深拷贝 -方式二 通过对象的序列化实现（推荐）
	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());//将当前对象写入 克隆
			ois = new ObjectInputStream(bis);
			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());
			}
		}
		
	}
	
}

测试

package creat.Prototye.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("小莉", "LiLi");
		
		//方式一 完成深拷贝
		DeepProtoType p2 = (DeepProtoType) p.clone();
		System.out.println("p.name= " + p.name + "   p.deepCloneableTarget= " + p.deepCloneableTarget.hashCode());
		System.out.println("p2.name= " + p2.name + "  p2.deepCloneableTarget= " + p2.deepCloneableTarget.hashCode());

		System.out.println("========");

		//方式二 完成深拷贝
		DeepProtoType p3 = (DeepProtoType) p.deepClone();
		System.out.println("p.name=" + p.name + " p.deepCloneableTarget= " + p.deepCloneableTarget.hashCode());
		System.out.println("p3.name=" + p3.name + " p3.deepCloneableTarget= " + p3.deepCloneableTarget.hashCode());

		//p.name= 多莉 p.deepCloneableTarget= 685325104
		//p2.name= 多莉 p2.deepCloneableTarget= 460141958  引用数据类型地址不一样，实现深拷贝
	}

}

4、原型模式的注意事项和细节

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

  1. 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提 高效率
  2. 不用重新初始化对象，而是动态地获得对象运行时的状态
  3. 如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，无需修改代码
  4. 在实现深克隆的时候可能需要比较复杂的代码
  5. 缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了ocp原则，这点请同学们注意.

5、更多设计模式

如果需要了解更多设计模式详情，请访问链接查看https://blog.csdn.net/qq_44392492/article/details/108309010

Windows10完美驱动Apple Studio Display：从雷电接口到亮度调节全攻略
最新发布
elastic6hunter的博客
02-11 1019
本文详细介绍了如何在Windows10系统上完美驱动Apple Studio Display，涵盖雷电接口兼容性、亮度调节及色彩管理等关键问题。通过实测对比不同转接方案和显卡兼容性，推荐使用贝尔金VR线和NVIDIA GTX-1660显卡，并提供了BootCamp驱动安装和亮度调节的终极解决方案，帮助用户实现最佳显示效果。
9篇3章3节：FAERS数据库公共仪表板搜索功能操作与解析
MD Code
10-06 1495
FAERS（FDA不良事件报告系统）公共仪表板是一个强大的工具，用于查询和分析药物及生物制品的不良事件数据。通过该仪表板，用户可以按药品或不良反应进行搜索，查看报告数量、事件类型及时间分布，从而辅助药物安全性分析和科研研究。本文重点介绍仪表板的搜索功能，包括按产品和按不良反应查询的操作步骤、筛选与多维数据分析方法，以及关键概念的解释，帮助用户科学、理性地使用FAERS数据，提升用药决策的准确性和安全性。
【设计模式】第四章：原型模式详解及应用案例
Bummon的学习随笔
06-13 700
摘自百度百科：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
黑客帝国数字屏保
黑客帝国数字屏保，酷炫可调节速度及反应时间，比较考验U，量力下载
设计模式——原型模式（附代码示例）
枫陵的博客
05-21 1647
一. 传统方法 以克隆羊为例 1. 代码示例 Sheep类，表示定义羊的模板 public class Sheep { private String name; private int age; private String color; public Sheep(String name, int age, String color) { this.name = name; this.age = age; ...
原型模式（实例）
qq_44889069的博客
05-15 5939
目录原型模式1、模式结构2、模式实例2.1 应用场景类图2.2 代码实现3、模式分析3.1 优点3.2 缺点3.3 适用场景 原型模式   原型模式是一种对象创建型模式，建造者模式是一种对象创建型模式，用原型模式可以用原型实例指定创建对象的种类，它允许通过一个原型对象创建多个同类型的其他对象，而无需知道该对象的创建细节，在Java中可以直接使用Object提供的clone()方法来实现对象的克隆（浅克隆）。 1、模式结构   Prototype：抽象原型类，给出所有的具体原型类所需的接口。   Concr
Java设计模式之创建型-原型模式（UML类图+案例分析）
黄团团的个人博客
07-11 1655
通过复制已有对象作为原型，通过复制该原型来返回一个新对象，而不是新建对象。原型模式通过对象复制获取实例,避免重复创建开销大的对象,是一种快速获取对象副本的模式，但需要注意副本状态的一致性管理。
05【原型设计模式】
緑水長流*z
08-16 1548
原型设计模式的核心在于复制原型对象，。有了原型设计模式就不需要我们来创建对象了，直接基于原型的实例对象进行克隆就可以；上面的代码就是没有原型设计模式之前的对象复制，使用起来非常繁琐，麻烦。原型设计模式就是来帮助我们避免上述代码来负责对象，采用更加优雅的方式进行对象的复制；......
创意设计模式：原型设计模式
新华编程特战队
01-09 1543
原型设计模式是创建性设计模式之一。它允许我们指定作为原始对象原型的对象。换句话说，它允许我们复制现有对象而不是创建新实例。在这里，我们将详细了解原型设计模式及其用法。
设计模式-原型设计模式
Ludy
07-24 205
一、原型设计模式的定义与特点 原型设计模式：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。 应用场景： 对象之间相同或相似，即只是个别的几个属性不同的时候。 对象的创建过程比较麻烦，但复制比较简单的时候。 模式的结构 原型模式包含以下主要角色。 抽象原型类：规定了具体原型对象必须实现的接口。 具体原型类：实现抽象原型类的 clon...
python 实现原型设计模式
1_bit 的博客
06-28 3027
原型设计模式主要在当新建一个对象的时候，觉得很麻烦，并且你又要保留当前对象。在这种情况下使用原型设计模式是一个很好的解决办法。 例如你写一个东西更新，不同的版本，这个时候以前的版本肯定要保留，并且从此基础上进行迭代，这个时候你就需要新建一个副本进行二次编写或者开发，进行新功能编写。 在我理解，设计模式是一种设计思想、解决方案，并不局限于固定的代码编写方式，只要符合于该思想即可，所以代码的实现只是一个实现样例，并不是唯一答案。毕竟条条道路通北京，怎么走还是得看你自己。 想要完全的从实际业务上考虑代码设计所使用
设计模式之原型设计模式
qq_74811378的博客
09-01 1610
① 覆盖 clone 方法 ( 必须 ) : 必须重写对象的 clone 方法 , Java 中提供了 cloneable 标识该对象可以被拷贝 , 但是必须覆盖 Object 的 clone 方法才能被拷贝;② 流程简单 : 原型模式可以简化创建的过程 , 可以直接修改现有的对象实例的值 , 达到复用的目的;原型模式主要用于对象的复制，它的核心是就是类图中的原型类 Prototype。深拷贝是指当一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝。
设计模式——原型设计模式
danfengw的博客
09-23 620
定义：指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 特点：不需要知道任何创建的细节，不调用构造函数 创建型 使用场景 类初始化消耗较多资源 new 产生的一个对象需要非常繁琐的过程（数据准备、访问权限等） 构造函数比较复杂 循环体中生产大量对象时 优点： 原型模式性能比直接new一个对象性能高 简化创建过程 缺点： 必须配备克隆方法 对克隆复杂对象或对克隆出的对象进行复杂改造时...
设计模式——原型设计模式（创建型）
庄小焱
05-31 1573
本文详细介绍了原型设计模式，这是一种创建型设计模式，通过复制现有对象（原型）来创建新对象，避免使用new关键字，可提高性能并简化对象创建逻辑。文章阐述了其优点，如提高性能、动态扩展和简化构造逻辑，以及缺点，如深拷贝实现复杂、复杂资源复制困难和易破坏封装性。还介绍了使用条件、结构、实现方式、适合场景和实战示例，并探讨了Spring中原型思想的应用。
设计模式总结-原型设计模式
lw的博客
04-05 1483
原型模式(Prototype Pattern)：原型模式是一种对象创建型模式，用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。原型模式允许一个对象再创建另外一个可定制的对象，无须知道任何创建的细节。原型模式的基本工作原理是通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝原型自己来实现创建过程。
创建设计模式 - 原型设计模式
YunWisdom
01-01 312
创建设计模式 -原型设计模式 原型设计模式是Creational Design模式之一，因此它提供了一种对象创建机制。 原型设计模式 当对象创建成本高昂并且需要大量时间和资源并且您已经存在类似对象时，使用原型设计模式。 原型模式提供了一种机制，可以将原始对象复制到新对象，然后根据需要对其进行修改。原型设计模式使用java克隆来复制对象。 原型设计模式示...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值