java设计模式-原型模式

最新推荐文章于 2025-08-18 08:22:50 发布
原创 最新推荐文章于 2025-08-18 08:22:50 发布 · 206 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨了原型模式的概念，其在创建型设计模式中的角色，以及如何通过浅拷贝和深拷贝来实现对象的高效复制。通过具体代码示例，详细解释了两种拷贝方式的区别和应用场景。

什么是原型（Prototype）模式

  • 原型模式是一个创建型模式
  • 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象;即对象的拷贝;

优缺点

  • 优点：在初始化信息不发生变化的情况下，使用克隆，即隐藏了对象的创建细节，对性能有提升;
  • 缺点：每个类必须准备一个clone方法，且clone方法需要对类的功能进行考虑;

简单的UML图

原型模式UML简图

原型模式的应用场景（相对来说）

  • new 构造对象需要非常繁琐的数据准备时，可以使用原型模式，进行对象的快速复制；
  • 多方使用当前对象，且都会对当前对象进行修改，调用方又相互独立，各自修改的值不想影响到其他调用方时，可以考虑通过原型模式复制多个对象(深拷贝)供调用方使用；
  • 创建对象时，需要保留原型对象的数据时；
  • 注意，通过实现Cloneable接口的原型模式在调用clone()方法并不一定都比new构造对象快，只有new构造对象较为耗时或成本较高时考虑使用；所以使用前需要仔细考虑，并进行相应的测试；
  • 原型模式利用对象拷贝的形式实现，需要注意对象的浅拷贝、深拷贝的不同

浅拷贝

浅拷贝是指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象。

clone实现浅拷贝

public class ShallowClone implements Cloneable {

    private boolean flag;

    private Integer index;

    private String str;

    private ShallowPeople shallowPeople;


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

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public Integer getIndex() {
        return index;
    }

    public void setIndex(Integer index) {
        this.index = index;
    }

    public ShallowPeople getShallowPeople() {
        return shallowPeople;
    }

    public void setShallowPeople(ShallowPeople shallowPeople) {
        this.shallowPeople = shallowPeople;
    }

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "ShallowClone{" +
                "flag=" + flag +
                ", index=" + index +
                ", str='" + str + '\'' +
                ", shallowPeople=" + shallowPeople +
                '}';
    }
}

public class ShallowPeople {

    private String name;

    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

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

public class CloneMain {

    private static final Log LOGGER = LogFactory.getLog(CloneMain.class);

    public static void main(String [] args) throws Exception {
        shallowClone();
        System.out.println("-----------------------------------------");
        depthClone();
        System.out.println("-----------------------------------------");
        depthCloneSerializable();
    }

    /**
     * 浅拷贝测试
     */
    private static void shallowClone() {
        ShallowClone shallowClone = new ShallowClone();
        shallowClone.setFlag(true);
        shallowClone.setIndex(1);
        ShallowPeople shallowPeople = new ShallowPeople();
        shallowPeople.setAge(12);
        shallowPeople.setName("xiaoming");
        shallowClone.setShallowPeople(shallowPeople);
        shallowClone.setStr("123");

        System.out.println("原：" + shallowClone);
        /**
         * 这里可以看出，修改clone出来的对象里的ShallowPeople 信息，影响到了原对象
         * 这是因为浅拷贝是指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象。
         */
        ShallowClone shallowClone1 = null;
        try {
            shallowClone1 = (ShallowClone) shallowClone.clone();
        } catch (CloneNotSupportedException e) {
            LOGGER.error("shallow clone error : {}", e);
            return;
        }
        shallowClone1.getShallowPeople().setName("heihei");
        shallowClone1.setStr("456");
        System.out.println("新：" + shallowClone1);
        System.out.println("原1：" + shallowClone);
    }


    /**
     * 深拷贝测试
     */
    private static void depthClone() {
        DepthClone depthClone = new DepthClone();
        depthClone.setFlag(false);
        depthClone.setIndex(2);
        DepthPeople depthPeople = new DepthPeople();
        depthPeople.setAge(11);
        depthPeople.setName("xiaoqiang");
        depthClone.setDepthPeople(depthPeople);

        System.out.println("原：" + depthClone);

        /**
         * 这里可以看出，修改clone出来的对象里的ShallowPeople 信息，对原对象无影响
         * 这是因为深拷贝不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象。
         *
         * 通过例子看出，深拷贝则是对浅拷贝的递归
         */
        DepthClone depthClone1 = null;
        try {
            depthClone1 = (DepthClone) depthClone.clone();
        } catch (CloneNotSupportedException e) {
            LOGGER.error("depth clone error : {}", e);
            return;
        }
        depthClone1.getDepthPeople().setName("heihei");
        System.out.println("新：" + depthClone1);
        System.out.println("原1：" + depthClone);
    }

    private static void depthCloneSerializable() {
        DepthCloneSerializable depthCloneSerializable = new DepthCloneSerializable();
        depthCloneSerializable.setFlag(true);
        depthCloneSerializable.setIndex(3);
        People people = new People();
        people.setAge(20);
        people.setName("xiaoliu");
        depthCloneSerializable.setPeople(people);

        System.out.println("原：" + depthCloneSerializable);
        DepthCloneSerializable depthCloneSerializable1 = null;
        try {
            depthCloneSerializable1 = (DepthCloneSerializable) depthCloneSerializable.deepClone();
        } catch (Exception e) {
            System.err.println("depthCloneSerializable error : " + e.getMessage());

            LOGGER.error("depthCloneSerializable error : {}", e);
            return;
        }
        depthCloneSerializable1.getPeople().setName("heihei");
        System.out.println("新：" + depthCloneSerializable1);
        System.out.println("原1：" + depthCloneSerializable);
    }
}

我们可以通过输出结果看出，浅拷贝生成的对象中的ShallowPeople信息修改，影响到了原型对象，原因是因为浅拷贝是仅拷贝对象本身，不拷贝对象内包含的引用指向的对象，且保留引用；
浅拷贝结果

深拷贝

深拷贝不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象

clone实现深拷贝

public class DepthClone implements Cloneable {

    private boolean flag;

    private Integer index;

    private DepthPeople depthPeople;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        DepthClone depthClone = null;
        try {
            depthClone = (DepthClone) super.clone();
            depthClone.setDepthPeople((DepthPeople) depthClone.getDepthPeople().clone());
        } catch (CloneNotSupportedException e) {
            throw e;
        }

        return depthClone;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public Integer getIndex() {
        return index;
    }

    public void setIndex(Integer index) {
        this.index = index;
    }

    public DepthPeople getDepthPeople() {
        return depthPeople;
    }

    public void setDepthPeople(DepthPeople depthPeople) {
        this.depthPeople = depthPeople;
    }

    @Override
    public String toString() {
        return "DepthClone{" +
                "flag=" + flag +
                ", index=" + index +
                ", depthPeople=" + depthPeople +
                '}';
    }
}


public class DepthPeople implements Cloneable {

    private String name;

    private Integer age;

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

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

我们可以通过输出结果看出，深拷贝并没有对原型对象有任何影响；
深拷贝结果
通过以上实现可以看出，通过clone实现深拷贝，其实就是对原型对象的所有子引用对象进行再次clone；类似对浅拷贝的一种递归实现。

通过序列化的方式实现深拷贝

public class DepthCloneSerializable implements Serializable {

    private boolean flag;

    private Integer index;

    private People people;

    public Object deepClone() throws IOException, SecurityException, ClassNotFoundException {
        // 写出去

        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bo);
        oos.writeObject(this);
        // 读回来
        ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bi);
        return ois.readObject();
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public Integer getIndex() {
        return index;
    }

    public void setIndex(Integer index) {
        this.index = index;
    }

    public People getPeople() {
        return people;
    }

    public void setPeople(People people) {
        this.people = people;
    }

    @Override
    public String toString() {
        return "DepthCloneSerializable{" +
                "flag=" + flag +
                ", index=" + index +
                ", people=" + people +
                '}';
    }

}

public class People implements Serializable {
    private String name;

    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

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

拷贝结果
序列化方式的深拷贝结果

copyProperties工具及比较

引用：copyProperties工具及比较
引用：Orika介绍
Orkia

Java创建型设计模式-原型模式
在技术的广袤天地里，本博客如精准罗盘。剖析前沿科技，深掘代码奥秘，以精炼笔触，带您穿越复杂技术迷宫，速达知识彼岸。
08-11 1278
原型模式是一种创建型设计模式，‌它允许通过复制一个已经存在的对象来创建一个新的对象，‌而无需重新实例化。‌这种模式特别适用于那些需要创建类似对象的情况，‌可以避免重复的代码和资源浪费。‌原型模式的核心在于提供一个原型对象，‌通过这个原型对象来生成其他对象，‌而不需要知道这些对象的类结构。‌在本文，我们学习了Java的一种创建型设计模式原型模式，知道它拥有原型接口具体原型类客户端和克隆方法四个角色，还阐述了原型模式的使用场景，以及呈现了原型模式的代码示例，相信大家应该对原型模式不陌生了！！
Java设计模式----原型模式（三种方法实现）
An_person的博客
07-10 864
原型模式（PrototypePattern）: 原型模式是指用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象(原型模式也是一种对象创建模式)。适合原型的情景：程序需要从一个对象出发，得到若干个和其状态相同，并可独立变化其状态的对象时；对象创建需要独立于它的构造方法和表示时；以原型对象为基础，克隆新的对象，并且完善对象实例变量时。 原型模式分为浅复制和深复制。 1.浅复制： 如果原型对...
Java 设计模式-原型模式
精神小牛马
07-24 1262
java 设计模式-原型模式
Java设计模式-原型模式
最新发布
weixin_66095070的博客
08-18 1173
Java原型模式摘要 原型模式是一种创建型设计模式，通过克隆现有对象来创建新对象，避免重复执行高成本初始化操作。核心思想是让对象能够复制自身，客户端只需调用clone()方法即可获得新实例，无需关心对象创建细节。 关键点： 适用于对象创建成本高的场景（如涉及IO、数据库访问） 通过克隆避免重复初始化，提升性能 主要角色包括抽象原型、具体原型和客户端 相比传统new创建方式，能显著减少重复操作开销 优势： 提升性能、简化创建流程、支持动态配置 典型应用： 图形系统、游戏角色生成、报表模板等需要大量相似对象的场
java设计模式-原型模式(PrototypePattern)
qq_37400096的博客
09-20 975
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
03-JAVA设计模式-原型模式
丨Anna丨的博客
04-08 1341
Java原型模式（Prototype Pattern）是一种创建型设计模式，其核心理念在于通过复制（克隆）已有的对象来创建新的对象，而不是通过构造函数来创建。该模式可以显著提高对象创建的效率，特别是在需要频繁创建对象或对象创建过程较为复杂的场景下。在原型模式中，原型对象作为基础对象，其他对象通过复制这个原型对象来创建新的实例。复制过程可以是浅克隆或深克隆。注意：发生浅拷贝主要针对数据类型为引用类型。
JAVA设计模式--原型模式
热门推荐
pengjunlee的博客
05-23 4万+
目录 一、什么是原型模式 二、原型模式实现 简单形式 登记形式 三、Java中的深拷贝与浅拷贝(或深度克隆与浅度克隆) 四、原型模式应用场景 五、原型模式的特点 参考文章 一、什么是原型模式 原型（Prototype）模式是一种对象创建型模式，它通过原型实例指定创建对象的种类，并采用拷贝原型实例的方法来创建新的对象。所以，使用原型模式创建的实例，具有与原型实例一样的数据。 ...
java设计模式之原型模式
尼古拉斯大树的博客
01-03 1724
java设计模式之原型模式简单介绍和代码demo
Java 设计模式：原型模式详解
云淡风轻
04-09 603
原型模式的核心思想是：通过克隆已有对象（原型）来生成新对象，而不是通过构造函数重新创建。它利用对象的复制机制，提高创建效率，并支持动态扩展。
设计模式-原型模式
明戈戈的博客
06-13 1459
因此，使用Obiect.clone()方法只能浅层次的克隆，即只能对那些成员变量是基本类型或String类型的对象进行克隆，对那些成员变量是类类型的对象进行克隆要使用到对象的序列化，不然克降出来的 Prototype 对象都共享同一个 obj 实例。用面向对象的方法来说就是，我们先建立一个原型，然后通过对原型进行复制和修饰的方法，就可以产生一个与原型相似的新对象。从以上的使用可以看出，在Java中Prototype 模式变成 clone()方法的使用，此方法执行的是该对象的“浅复制”，而不“深复制”操作。
JAVA-设计模式-创建型模式-原型模式
08-10
JAVA-设计模式-创建型模式-原型模式
精选资源
软件设计模式 - 原型模式PPT
03-07
原型模式（Prototype Pattern）是软件设计模式中的一种创建型模式，它的核心在于利用已有的一个原型对象，通过复制这个原型对象创建出新的对象。这种方法可以避免重复的初始化操作，或者避免重复的构造过程带来的...
ava常用设计模式-原型模式
08-26
ava常用设计模式-原型模式 原型模式（Prototype Pattern）是一种创建型设计模式，允许通过复制现有对象来创建新对象，而不是通过实例化类来创建新对象。在需要创建大量相似对象时非常有用，它可以避免重复创建对象...
24设计模式-原型模式1
08-04
原型模式是一种设计模式，主要目的是通过复制现有对象来创建新对象，从而简化创建过程并减少对象构造的开销。在Java中，实现原型模式通常涉及`Cloneable`接口和`clone()`方法。`Cloneable`接口是一个标记接口，类...
echarts结合poi-word导出的简单处理
code1Boy的博客
07-30 1万+
echarts结合poi-word导出的简单处理获取图像echarts是通过canvas进行图表的绘制的，所以可以通过canvas来获取图片的base64编码,然后将base64编码传到后台进行处理。 1.如何获取报表图片的base64编码： $('canvas').toDataURL(); //打印出base64编码。 2.如何将编码充送给后台 我是通过spring-mvc 结合a
FastJson序列化驼峰-下划线转换问题踩坑记录
code1Boy的博客
08-29 3150
1.这种全局配置要谨慎使用，且这种加载优先级设置还不是最高的，且不好被开发人员发现的配置话尽量少用吧，避免坑自己更避免坑别人2.对于老服务，还是需要多观察下配置。
使用mybatis进行批量处理sql语句
code1Boy的博客
03-04 3077
使用注解： 以此注解为例@UpdateProvider： 注解参数：@UpdateProvider(type = SqlProvider.class, method = “update”) type： SqlProvider 对应的sql提供者java类； method ： 此方法对应 sql提供者类中的专门给此方...
校验字符串是否全部是中文或·
code1Boy的博客
08-31 1427
boolean b = "哈哈".matches("[\\u4E00-\\u9FA5·]+");
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值