小侃设计模式（四）-原型模式

已于 2024-01-04 13:40:38 修改
阅读量305 收藏 1
点赞数 1
分类专栏： 设计模式 文章标签： java 设计模式
于 2022-11-03 16:51:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33479841/article/details/127602513
版权

1.概述

原型模式（Prototype Pattern）适用于创建重复的对象，同时又能保证性能，它提供了一种创建对象的最佳方式。JAVA中原型模式通过实现一个原型接口，该接口用于创建对象的克隆，当创建对象的代价比较大时，采用这种模式能够有效提升系统性能。它是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节，本文主要讲述JAVA中采用浅拷贝和深拷贝方式来实现原型模式。

2.原型模式

原型模式指的是：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。它通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。

案例：有一只羊名叫多利，现在需要通过克隆方式，生成3个和它一样的羊。在JAVA中的代码实现如下：

public class Sheep implements Cloneable {

    private Integer age;

    private String color;

    private String name;

    public Integer getAge() {
        return age;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getName() {
        return name;
    }

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

    @Override
    protected Object clone() {
        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return sheep;
    }
}


public class Main {
    public static void main(String[] args) {
        Sheep sheep = new Sheep();
        sheep.setAge(3);
        sheep.setName("多利");
        sheep.setColor("black");
        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();
       
        System.out.println(JSON.toJSONString(sheep1));
        System.out.println(JSON.toJSONString(sheep2));
        System.out.println(JSON.toJSONString(sheep3));
    }
}

运行结果如下：
在这里插入图片描述

2.1 浅拷贝

在JAVA中，对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。对于数据类型是引用数据类型的成员变量（比如说成员变量是某个数组，某个类的对象等），那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。也就是说，浅拷贝的对象直接会互相干扰，一旦其中一个对象修改某个引用数据类型的成员变量，会改变这个对象拷贝出来的所有对象该成员变量。

案例：上述克隆羊的案例中，如果每只小羊有一个成员属性friend，用来存储自己的朋友，用原型模式生成sheep1、sheep2、sheep3时，friend的哈希地址相同。代码如下：

public class Sheep implements Cloneable {

    private Integer age;

    private String color;

    private String name;

    private Sheep friend;

    public Integer getAge() {
        return age;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getName() {
        return name;
    }

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

    public Sheep getFriend() {
        return friend;
    }

    public void setFriends(Sheep friend) {
        this.friend = friend;
    }

    @Override
    protected Object clone() {
        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return sheep;
    }
}

public class Main {
    public static void main(String[] args) {
        Sheep sheep = new Sheep();
        sheep.setAge(3);
        sheep.setName("多利");
        sheep.setColor("black");
        Sheep friend = new Sheep();
        friend.setName("小羊克隆");
        friend.setColor("red");
        friend.setAge(1);
        sheep.setFriend(friend);
        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();

        System.out.println(JSON.toJSONString(sheep1) + ":" + "hashCode:" + sheep1.getFriends().hashCode());
        System.out.println(JSON.toJSONString(sheep2) + ":" + "hashCode:" + sheep2.getFriends().hashCode());
        System.out.println(JSON.toJSONString(sheep3) + ":" + "hashCode:" + sheep3.getFriends().hashCode());
    }
}

运行结果如下：
在这里插入图片描述

2.2 深拷贝

深拷贝与浅拷贝不同，深拷贝不仅会复制对象的所有基本数据类型的成员变量值，还会为所有引用数据类型的变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝。
深拷贝主要有以下两种方式：1.重写clone方法来实现深拷贝；2.通过对象序列化实现深拷贝。

2.2.1 重写clone方法来实现深拷贝

由于引用类型不能实现深拷贝，所以将引用类型拆分成基本类型，重写每个引用类型的clone()方法。这种方式的缺陷在于如果引用类型还嵌套引用类型，那么需要在每个引用类型中重写clone()方法，有多少个引用类型就要重写多少次，代价太大且违背开闭原则。

public class Sheep implements Cloneable, Serializable {

    private Integer age;

    private String color;

    private String name;

    private Sheep friend;

    public Integer getAge() {
        return age;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getName() {
        return name;
    }

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

    public Sheep getFriend() {
        return friend;
    }

    public void setFriend(Sheep friend) {
        this.friend = friend;
    }

    @Override
    protected Object clone() {
        Sheep sheep = null;
        try {
        //对基本数据类型（属性）和String类型的克隆
            sheep = (Sheep) super.clone();
            //对引用类型的属性的单独克隆
            Sheep clone = (Sheep) friend.clone();
            sheep.friend = clone;
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return sheep;
    }
}

public class Main {
    public static void main(String[] args) {
        Sheep sheep = new Sheep();
        sheep.setAge(3);
        sheep.setName("多利");
        sheep.setColor("black");
        Sheep friend = new Sheep();
        friend.setName("小羊克隆");
        friend.setColor("red");
        friend.setAge(1);
        sheep.setFriend(friend);
        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();

        System.out.println(JSON.toJSONString(sheep1) + ":" + "hashCode:" + sheep1.getFriend().hashCode());
        System.out.println(JSON.toJSONString(sheep2) + ":" + "hashCode:" + sheep2.getFriend().hashCode());
        System.out.println(JSON.toJSONString(sheep3) + ":" + "hashCode:" + sheep3.getFriend().hashCode());
    }
}

运行结果如下：
在这里插入图片描述

2.2.2 通过对象序列化实现深拷贝

通过序列化方式的实现原理是将原始对象利用序列化产生克隆对象，然后反序列化获取这个对象。由于序列化产生的是两个完全独立的对象，所以无论对象嵌套多少个引用类型，序列化都能够实现深拷贝。

public class Sheep implements Cloneable, Serializable {

    private Integer age;

    private String color;

    private String name;

    private Sheep friend;

    public Integer getAge() {
        return age;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getName() {
        return name;
    }

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

    public Sheep getFriend() {
        return friend;
    }

    public void setFriend(Sheep friend) {
        this.friend = friend;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        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);
            Sheep copyObj = (Sheep) ois.readObject();
            return copyObj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                ois.close();
                bos.close();
                oos.close();
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}


public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheep = new Sheep();
        sheep.setAge(3);
        sheep.setName("多利");
        sheep.setColor("black");
        Sheep friend = new Sheep();
        friend.setName("小羊克隆");
        friend.setColor("red");
        friend.setAge(1);
        sheep.setFriend(friend);
        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();

        System.out.println(JSON.toJSONString(sheep1) + ":" + "hashCode:" + sheep1.getFriend().hashCode());
        System.out.println(JSON.toJSONString(sheep2) + ":" + "hashCode:" + sheep2.getFriend().hashCode());
        System.out.println(JSON.toJSONString(sheep3) + ":" + "hashCode:" + sheep3.getFriend().hashCode());
    }
}

运行结果如下：
在这里插入图片描述

2.2.3 原型模式的优势和缺点

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

3.小结

1.原型模式是期望通过一种低损耗的方式来快速创建对象，JAVA中使用这种方式，需要实现Cloneable接口并重写clone()方法；
2.浅拷贝适用于一个类只拥有基本类型，深拷贝适用于拥有基本类型和引用类型的类；
3.原型模式主要适用于创建大对象或者批量创建大量相同对象的场景。

4.参考文献

1.《设计模式-可复用面向对象软件的基础》-Erich Gamma、Richard Helm、Ralph Johnson、John Vlissides
2.《可复用物联网Web3D框架的设计与实现》-程亮（知网）
3.https://www.bilibili.com/video/BV1G4411c7N4-尚硅谷设计模式

程可爱
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式（六）原型模式
xingjiarong的专栏
11-28 2430
一、说说鸣人的影分身 话说鸣人听了水木老师的建议偷出了卷轴并且学会了一招禁术：影分身之术。当鸣人使用影分身之术的时候就会有好多个和鸣人一模一样的人出现，就像复制出来的一样，这种影分身之术在面向对象的设计领域里就叫做原型模式。 二、什么是原型模式 有了上边的鸣人的例子，我们再理解圆形模式的定义应该会更简单了，GOF给它的定义是：用原型实例指定创建对象的种类并且通过拷贝这些原型对象创建新的对象。
设计模式（三）原型模式
qq_59415584的博客
04-25 185
原型模式 黑马程序员：https://www.bilibili.com/video/BV1Np4y1z7BU?p=46 概述 用一个已经创建的实例作为原型，通过赋值该原型对象来创建一个和原型对象相同的新对象。 结构 原型模式包含的角色： 抽象原型类：规定了具体原型对象必须实现的clone()方法； 具体原型类：实现抽象原型类clone()方法，它是可以被复制的对象； 访问类：使用具体原型类中的clone()方法来复制新的对象。 分类 浅克隆： 创建一个新对象，新对象的属性和原来对象完全相同，对于非
设计模式详解之原型模式
eclipse_xu
03-14 1973
原型模式（Prototype）： 原型模式虽然是创建型的模式，但是与工程模式没有关系，从名字即可看出，该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。本小结会通过对象的复制，进行讲解。在Java中，复制对象是通过clone()实现的，先创建一个原型类： public class Prototype implements Cloneable { publ
小侃设计模式（十六）-备忘录模式
qq_33479841的博客
12-07 732
备忘录模式（Memento Pattern）是一种行为型模式，它的主要思想是在不破坏封装性的前提下，捕获一个对象的内部状态，并将该状态保存在该对象之外，这样以后就可将该对象恢复到原先保存的状态。它是相对简单的一种设计模式，能够允许用户取消不确定或者错误的操作，能够恢复到之前的状态。本文将详述备忘录模式的原理及使用方式。
ava常用设计模式-原型模式
08-26
ava常用设计模式-原型模式 原型模式（Prototype Pattern）是一种创建型设计模式，允许通过复制现有对象来创建新对象，而不是通过实例化类来创建新对象。在需要创建大量相似对象时非常有用，它可以避免重复创建对象...
Java设计模式-原型模式详解
11-24
Java 设计模式 - 原型模式详解 原型模式是 Java 设计模式之一，它用于创建对象时，指定创建对象的类型，并通过拷贝这些原型创建新的对象。该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原...
24设计模式-原型模式1
08-04
原型模式是一种设计模式，主要目的是通过复制现有对象来创建新对象，从而简化创建过程并减少对象构造的开销。在Java中，实现原型模式通常涉及`Cloneable`接口和`clone()`方法。`Cloneable`接口是一个标记接口，类...
JAVA-设计模式-创建型模式-原型模式
08-10
JAVA-设计模式-创建型模式-原型模式
C# 设计模式系列教程-原型模式
01-21
2. 模式中的角色 　2.1 抽象原型类（Abstract Prototype）：提供一个克隆接口 　2.2 具体原型类（Concrete Prototype）: 及实现了克隆接口的具体原型类 3. 实例：求职网站上现在都支持多份简历，如果每创建一份简历...
【Spring框架】
m0_71941456的博客
08-18 1040
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
网上商品订单转手系统bootpf
weixin_43213064的博客
08-18 568
【代码】springboot网上商品订单转手系统bootpf
指针详解（四）
Limerence_Aries的博客
08-18 1034
目录1. 字符指针变量2. 数组指针变量3. 数组指针变初始化4. 二维数组传参的本质5. 函数指针变量1）函数指针变量的创建2）函数指针变量的使用3）代码解析6. typedef关键字7. 函数指针数组8. 转移表 代码const char* pstr = "hello bit."; 不是把字符串 hello bit 放到字符指针 pstr 里，而是把字符串hello bit.的首字符的地址放到了pstr中我们通过一道例题加深理解 所以数组指针变量：存放的应该是数组的地址，能够指向数组的指针变
android apk 加固后的地图加载异常及重新签名
calivnBao的博客
08-20 223
android apk 加固后的地图加载异常及重新签名
Java学习_18_Stream流
最新发布
qq_41136689的博客
08-23 997
博客仅记录个人学习进度和一些查缺补漏。学习内容：BV17F411T7Ao流的出现让数据处理从几十行代码缩减到一两行就能实现，简化了很多集合数组的操作。
微服务框架
Founder_Xiao_Xin的博客
08-20 777
在分布式系统中，服务可能失败导致雪崩，Hystrix 是防雪崩利器，具有服务降级、服务熔断、服务隔离、监控等防止雪崩的技术。服务降级：接口调用失败调用本地方法返回空。服务熔断：接口调用失败进入熔断方法返回错误信息。服务隔离：隔离服务之间相互影响。服务监控：记录服务调用的运行指标。在分布式系统中，一个业务因跨越不同数据库或不同微服务而包含多个子事务，要求所有子事务同时成功或失败，这就是分布式事务。例如某电商系统下单操作，需请求订单服务、账户服务、库存服务。
Javascript嵌套函数的调用
Cc040909的博客
08-17 778
闭包的嵌套函数就不同了，由于有两个函数，调用栈就标记为1， 表示内部还有函数，这个函数不知道什么时候才执行，所以js引擎就把他保存在内存中了。恰好第一个函数和第二个函数执行的时候，眼睛观察到的调用是看不到对象，所以执行的是默认绑定，都默认绑定在全局对象window上(浏览器环境)。上面这个总结的过程非常微妙，细节就在于嵌套的函数的分部执行过程，尽管内部函数嵌套在外部函数内，但是外部函数并没有影响内部函数的权利，内部函数的执行是不受外部函数控制的。外部函数和内部函数是两个不同的事件循环位置，独立调用的，
SpringBoot如何做自动配置
Z_DOUBLE_Y的博客
08-18 851
Spring Boot通过注解开启自动配置，对autoconfigured的jar包下的META-INF下的spring包中下的spring.factories文件进行扫描，这个文件中包含了可以进行自动配置的类，当满足@Condition注解指定的条件时，便在依赖的支持下进行实例化，注册到Spring容器中。用注解来对一些常规的配置做默认配置，简化了各种xml配置内容，使项目能够快速运行。
[笔记] hyperf event
BLOCKGOLD.E的博客
08-20 441
得益于组件的支撑，用户可以很方便的对以下事件进行监听。例如。接下来我们就实现一个记录SQL的监听器，来说一下怎么使用。首先我们定义好，实现接口并对类定义php/***//***/return [/***/if (!
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值