设计模式-原型模式（Prototype Pattern）

最新推荐文章于 2024-04-20 12:07:37 发布
最新推荐文章于 2024-04-20 12:07:37 发布
阅读量4.2k 收藏 1
点赞数 2
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37960603/article/details/104081344
版权

推荐：Java设计模式汇总

原型模式

定义
使用原型实例指定待创建的类型，并且通过复制这个原型实例来创建新的对象。

类型
创建型。

例子
Mail类（邮件类），实现了Cloneable接口(只有实现了该接口的类的实例才可以调用clone()方法克隆实例,否则会抛出异常)。

package com.kaven.design.pattern.creational.prototype;

public class Mail implements Cloneable{
    private String name;
    private String emailAddress;
    private String content;
    public Mail(){
        System.out.println("Mail Class Constructor");
    }

    public String getName() {
        return name;
    }

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

    public String getEmailAddress() {
        return emailAddress;
    }

    public void setEmailAddress(String emailAddress) {
        this.emailAddress = emailAddress;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "Mail{" +
                "name='" + name + '\'' +
                ", emailAddress='" + emailAddress + '\'' +
                ", content='" + content + '\'' +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        System.out.println("clone mail object");
        return super.clone();
    }
}

Cloneable接口只是起到告诉程序这个类的实例可以调用clone方法的作用，它本身并没有定义任何方法。
源码如下：

package java.lang;
public interface Cloneable {
}

MailUtil类（邮件的工具类），调用sendMail()方法可以发送邮件。

package com.kaven.design.pattern.creational.prototype;

import java.text.MessageFormat;

public class MailUtil {
    public static void sendMail(Mail mail){
        String outputContent = "向 {0} 同学，邮件地址:{1}，邮件内容：{2}，发送邮件成功";
        System.out.println(MessageFormat.format(outputContent,mail.getName(),mail.getEmailAddress(),mail.getContent()));
    }
}

应用层代码：

package com.kaven.design.pattern.creational.prototype;

public class Test {
    private static String[] name = {"yy","kaven","jack","jojo"};
    public static void main(String[] args) throws CloneNotSupportedException {
        Mail mail = new Mail();
        mail.setContent("初始化模板");
        for (int i = 0; i < name.length; i++) {
            Mail mailTemp = (Mail) mail.clone();
            mailTemp.setName(name[i]);
            mailTemp.setEmailAddress(name[i]+"@lkwyy.com");
            mailTemp.setContent("恭喜您，此次活动中奖了");
            MailUtil.sendMail(mailTemp);
        }
    }
}

结果：

Mail Class Constructor
clone mail object
向 yy 同学，邮件地址:yy@lkwyy.com，邮件内容：恭喜您，此次活动中奖了，发送邮件成功
clone mail object
向 kaven 同学，邮件地址:kaven@lkwyy.com，邮件内容：恭喜您，此次活动中奖了，发送邮件成功
clone mail object
向 jack 同学，邮件地址:jack@lkwyy.com，邮件内容：恭喜您，此次活动中奖了，发送邮件成功
clone mail object
向 jojo 同学，邮件地址:jojo@lkwyy.com，邮件内容：恭喜您，此次活动中奖了，发送邮件成功

Mail mail = new Mail()会调用构造器创建原型实例，调用构造器时会输出Mail Class Constructor，而每次要发送的邮件都是对这个原型实例的克隆Mail mailTemp = (Mail) mail.clone();，并且可以发现clone()方法不会调用构造器，对象拷贝时构造器是不会被执行的，Object类的clone()方法的原理是从内存中（具体的说，就是堆内存中）以二进制流的方式进行拷贝，并且会重新分配一个内存块（也是堆内存中），也就不需要调用构造器了 。
这里我们便实现了一个简单的原型模式例子，接下来我们分析一下克隆的问题。

深克隆与浅克隆

package com.kaven.design.pattern.creational.prototype.clone;

import java.util.Date;

public class Pig implements Cloneable {
    private String name;
    private Date birthday;

    public Pig(String name, Date birthday) {
        this.name = name;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

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

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

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

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

测试1：

package com.kaven.design.pattern.creational.prototype.clone;

import java.util.Date;

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Pig pig = new Pig("佩奇",new Date(0L));
        Pig clonePig = (Pig) pig.clone();

        System.out.println(pig);
        System.out.println(clonePig);
        System.out.println(pig == clonePig);
    }
}

输出：

Pig{name='佩奇', birthday=Thu Jan 01 08:00:00 CST 1970}
Pig{name='佩奇', birthday=Thu Jan 01 08:00:00 CST 1970}
false

很显然它们不是指向同一个实例，因为会重新分配一个内存块。

测试2：

package com.kaven.design.pattern.creational.prototype.clone;

import java.util.Date;

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Pig pig = new Pig("佩奇",new Date(0L));
        Pig clonePig = (Pig) pig.clone();

        System.out.println(pig);
        System.out.println(clonePig);

        clonePig.getBirthday().setTime(1000000000000L);
        System.out.println(pig);
        System.out.println(clonePig);
    }
}

输出：

Pig{name='佩奇', birthday=Thu Jan 01 08:00:00 CST 1970}
Pig{name='佩奇', birthday=Thu Jan 01 08:00:00 CST 1970}
Pig{name='佩奇', birthday=Sun Sep 09 09:46:40 CST 2001}
Pig{name='佩奇', birthday=Sun Sep 09 09:46:40 CST 2001}

为什么我们改变clonePig的birthday属性，pig的birthday属性也会进行改变？
我们来Debug一下。
打上断点：
在这里插入图片描述
开始Debug。
在这里插入图片描述
Debug后，可以发现pig（Pig@616）和clonePig（Pig@617）确实不是指向同一个实例，但它们的birthday属性却是指向相同的Date实例(Date@621)，这就是浅克隆，所以，当修改clonePig的birthday属性时，pig的birthday属性也会进行改变。
在这里插入图片描述
从上图可以看出，当修改了clonePig的birthday属性时clonePig.getBirthday().setTime(1000000000000L)，pig的birthday属性也会进行改变。

如何改进成深克隆呢？
改进如下：

package com.kaven.design.pattern.creational.prototype.clone;

import java.util.Date;

public class Pig implements Cloneable {
    private String name;
    private Date birthday;

    public Pig(String name, Date birthday) {
        this.name = name;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

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

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Pig clonePig = (Pig) super.clone();

        //深克隆
        clonePig.birthday = (Date) clonePig.birthday.clone();
        return clonePig;
    }
}

测试：

package com.kaven.design.pattern.creational.prototype.clone;

import java.util.Date;

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Pig pig = new Pig("佩奇",new Date(0L));
        Pig clonePig = (Pig) pig.clone();

        System.out.println(pig);
        System.out.println(clonePig);

        clonePig.getBirthday().setTime(1000000000000L);
        System.out.println(pig);
        System.out.println(clonePig);
    }
}

结果：

Pig{name='佩奇', birthday=Thu Jan 01 08:00:00 CST 1970}
Pig{name='佩奇', birthday=Thu Jan 01 08:00:00 CST 1970}
Pig{name='佩奇', birthday=Thu Jan 01 08:00:00 CST 1970}
Pig{name='佩奇', birthday=Sun Sep 09 09:46:40 CST 2001}

从测试结果上来看，当修改clonePig的birthday属性时，pig的birthday属性并没有进行改变。
这就改进成深克隆了吗？是的，这便是深克隆。
其实我们还依赖了Date类本身就实现了深克隆，我们才会如此方便，Date类的clone()方法源码如下：

    public Object clone() {
        Date d = null;
        try {
            d = (Date)super.clone();
            if (cdate != null) {
                d.cdate = (BaseCalendar.Date) cdate.clone();
            }
        } catch (CloneNotSupportedException e) {} // Won't happen
        return d;
    }

有些引用型没有这种浅克隆的问题，如String或Integer等包装类型，大家可以自己试一试。
还有就是，final修饰的成员变量是不能进行深度拷贝的。

适用场景

  • 类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等，通过原型拷贝避免这些消耗。
  • 通过new产生的一个对象需要非常繁琐的数据准备或者权限，这时可以使用原型模式。
  • 难以根据类生成实例时。
  • 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用，即保护性拷贝。
  • 想解耦框架与生成的实例时。

优点

  • 原型模式提供了简化的创建结构，常常与工厂方法模式一起使用。
  • 可以使用深克隆的方式保存对象的状态，在操作过程中可以追溯操作日志，做撤销和回滚操作。
  • 当创建新的对象实例较为复杂时，使用原型模式可以简化对象的创建过程，通过一个已有实例可以提高新实例的创建效率。

缺点

  • 需要为每一个类配备一个克隆方法，而且这个克隆方法需要对类的功能进行通盘考虑，这对全新的类来说不是很难，但对已有的类进行改造时，不一定是件容易的事，必须修改其源代码，违背了“开闭原则”。
  • 在做深克隆的时候，如果对象之间存在多重嵌套的引用时，为了实现克隆，对每一层对象对应的类都必须支持深克隆，实现起来比较麻烦。

如果有说错的地方，请大家不吝赐教（记得留言哦~~~~）。

ITKaven
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
原型模式（Prototype Pattern）原理图
04-10
原型模式是一种创建型设计模式，它通过复制一个现有的对象来创建新的对象，而不是通过调用构造函数的方式。这种方式可以在运行时动态地创建和修改对象，而不需要知道具体的创建细节 。 原型模式的基本概念包括以下...
原型模式(Prototype Pattern)--对象的克隆
weixin_34364071的博客
05-02 71
定义:使用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象; 原型类的核心在于如何实现克隆方法: 能够实现克隆的Java类必须实现一个标识接口Cloneable,表示这个类支持被复制; 通用实现方法; 利用Object类的clone()方法; // 1. 通用实现方法 // 通用的克隆实现方法是在具体原型类的克隆方法中实例化一个与自身类型相同的对象并将其返回,并将相关 // 参...
设计模式 | 三、原型模式(浅克隆、深克隆)[PrototypePattern]
GiraffePeng的博客
08-27 335
原型模式（Prototype Pattern）是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
java设计模式-原型模式(PrototypePattern)
qq_37400096的博客
09-20 462
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
C++设计模式-原型模式-Prototype pattern
guoguo0524的博客
06-08 88
【代码】C++设计模式-原型模式-Prototype pattern。
设计模式-4--原型模式（Prototype Pattern）
人生若只能如初见的博客
08-26 889
原型模式（Prototype Pattern）是一种创建型设计模式，它的主要目的是通过复制现有对象来创建新的对象，而无需显式地使用构造函数或工厂方法。这种模式允许我们创建一个可定制的原型对象，然后通过复制它来创建新的对象，从而避免了重复构建相似的对象。原型（Prototype）：定义了一个克隆自己的接口，它是需要复制的对象的抽象表示。具体原型（Concrete Prototype）：实现了原型接口，实现了克隆自己的方法。客户端（Client）：负责创建新对象，通过克隆已有的原型来获得新对象的副本。
009设计模式--原型模式(Prototype Pattern)
weixin_59237044的博客
12-16 87
设计模式之原型模式
设计模式- 原型模式(Prototype Pattern)
易兒善
04-26 266
定义 原型模式(Prototype Pattern)：指定使用原型实例创建的对象类型，并通过复制此原型创建新对象。 C#例子 [Serializable] public class Sheep : ICloneable { public string Name { get; set; } public List<Sheep> ...
设计模式 -- 原型模式（Prototype Pattern）
魔法师之家
03-21 448
设计模式 -- 原型模式；浅拷贝&深拷贝
设计模式- 原型模式（Prototype Pattern）结构|原理|优缺点|场景|示例
最新发布
piaomiao_的博客
04-20 927
原型模式（Prototype Pattern）是一种创建型设计模式，其主要目的是通过复制现有的对象（即原型）来创建新对象，而不是每次都通过new操作符来创建对象。这种模式适用于创建新对象的成本较大（如初始化耗时、占用资源较多）或者创建过程较复杂的场景，通过克隆原型对象可以快速、便捷地生成相似或相同状态的新对象。
.NET设计模式（6）：原型模式（PrototypePattern）
01-30
.NET设计模式（6）：原型模式（PrototypePattern）
原型模式 Prototype Pattern
03-09
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
design-pattern-test:设计模式学习
04-30
design-pattern-test 设计模式学习练习 模式可以分为三大类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）、行为型模式（Behavioral Patterns） 序号 模式&描述 包括 1 创建型模式---...
反射破坏单例模式以及如何防御
kaven
01-23 7316
反射破坏单例模式以及如何防御 需要了解实现单例模式的各种方法，可以参考下方这篇博客。 设计模式-单例模式（Singleton Pattern） 单例模式类Singleton，是使用静态内部类实现的单例模式。 package com.kaven.design.pattern.creational.singleton; public class Singleton{ private Sing...
设计模式-责任链模式（Chain of Responsibility Pattern）
kaven
01-31 5666
责任链模式 定义 为请求创建一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。 类型 行为型。 UML类图 角色 抽象处理者（BaseHandler）角色：定义处理请求的接口，并且有接下来要处理请求的处理者的引用。 具体处理者（ConcreteHandler）角色：实现抽象处理者角色中处理请求的接口。 例子 慕课网讲师上线新课程时，慕课网工作人员需要检查资料是否齐全...
设计模式-简单工厂模式（Simple Factory Pattern）
kaven
01-15 4737
简单工厂模式 定义 设计一个工厂类，给工厂类传入参数决定创建哪一种产品类的实例。 简单工厂模式是属于创建型模式，又叫做静态工厂方法模式。 类型 创建型，但不属于GOF23种设计模式。 适用场景 应用层只需要知道传入工厂类的参数，对于如何创建对象（逻辑）不需要关心。 优点 只需要传入一个正确的参数，就可以获取你所需要的对象，而无需知道其创建细节。 缺点 工厂类的职责相对过重，不易维护，增加新的产品可...
设计模式-单例模式（Singleton Pattern）
kaven
01-21 4698
单例模式 定义 确保一个类只有一个实例，并为整个系统提供一个全局访问点 (向整个系统提供这个实例)。 类型 创建型。 适用场景 网站访问量计数器。 项目中用于读取配置文件的类。 Spring中，每个Bean默认都是单例的，这样便于Spring容器进行管理。 优点 由于单例模式只生成了一个实例，所以能够节约系统资源、减少性能开销、提高系统效率。 缺点 不适合用于变化频繁的对象；如果实例化的对象长...
序列化破坏单例模式以及如何防御的应用与Debug分析
kaven
01-23 4615
反射、序列化破坏单例模式以及如何防御 需要了解实现单例模式的各种方法，可以参考下方这篇博客。 设计模式-单例模式（Singleton Pattern） 单例模式类Singleton，是使用静态内部类实现的单例模式，并且实现Serializable接口（不实现Serializable接口进行序列化会报错）。 package com.kaven.design.pattern.creational.si...
C#设计模式——原型模式(Prototype Pattern)
06-01
原型模式是一种创建型设计模式，它允许通过复制已有对象来创建新对象，而不是通过实例化类并设置其属性来创建新对象。这样可以避免重复创建相同的对象，从而提高了创建对象的效率。 在原型模式中，原型对象是被复制...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ITKaven

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

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

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

打赏作者

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

抵扣说明：

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

余额充值