设计模式详解（六）——原型模式

最新推荐文章于 2024-07-22 08:15:00 发布
最新推荐文章于 2024-07-22 08:15:00 发布
阅读量720 收藏 2
点赞数
文章标签： 原型模式 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44307209/article/details/130813444
版权

原型模式简介

原型模式定义
原型模式是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。就是用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。

原型模式包含以下角色：
抽象原型类：规定了具体原型对象必须实现的clone()方法
具体原型类：实现了抽象原型类的clone()方法,它是可以被复制的对象
访问类：使用具体原型类中的clone()方法来复制新对象

原型模式优缺点：
优点：
1.可以克隆对象， 无需与它们所属的具体类相耦合
2.可以克隆预生成原型， 避免反复运行初始化代码
3.可以更方便地生成复杂对象
4.可以用继承以外的方式来处理复杂对象的不同配置
5.性能提高
6.逃避构造函数的约束
7.java自带的原型模型基于内存二进制流的复制，在性能上比直接new一个对象更加优良

缺点：
1.克隆包含循环引用的复杂对象可能会非常麻烦
2.配备克隆方法需要对类的功能进行通盘考虑
3.必须实现 Cloneable 接口
4.需要为每一个类都配置一个 clone 方法
5.clone方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违背了开闭原则

使用场景

  1. 类初始化需要消化非常多的资源，这个资源包括数据、硬件资源
  2. 通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式
  3. 一个对象多个修改者的场景
  4. 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
  5. 如果需要复制一些对象， 同时又希望代码独立于这些对象所属的具体类， 可以使用原型模式
  6. 对象之间相同或相似，即只是个别的几个属性不同的时候
  7. 创建对象成本大，例如初始化时间长，占用CPU太多，或者占用网络资源太多等，需要优化资源
  8. 创建一个对象需要频繁的数据准备或访问权限等，需要提高性能或者提高安全性
  9. 系统中大量使用该类对象，且各个调用者都需要给它的属性重新赋值

原型模式的实现
原型模式的克隆分为浅克隆和深克隆，实现克隆的方式：
**浅克隆：**创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。或者创建一个新对象，复制对象时仅仅复制对象本身，包括基本属性，但该对象的属性引用其他对象时，该引用对象不会被复制，即拷贝出来的对象与被拷贝出来的对象中的属性引用的对象是同一个（仍指向原有属性所指向的对象的内存地址）；
**深克隆：**创建一个新对象，属性中引用的其他对象也会被克隆，即修改被克隆对象的任何属性都不会影响到克隆出来的对象（不再指向原有对象地址）

以下举一个例子：
克隆羊：
Sheep类实现了Cloneable接口，重写了clone方法：
1.主方法

/**
 * @author yyx
 */
public class Sheep implements Cloneable {
    private String name;
    private int age;
    private String color;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getColor() {
        return color;
    }

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

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

    //使用默认的克隆方法
    @Override
    protected Object clone() {
        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sheep;
    }
}

2.测试类Client

/**
 * @author yyx
 */
public class Client {
    public static void main(String[] args) {
        Sheep sheep = new Sheep("DuoLi", 5, "白色");
        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();

        System.out.println("sheep1=" + sheep1);
        System.out.println("sheep2=" + sheep2);
        System.out.println("sheep3=" + sheep3);
    }
}

运行结果如下所示：

sheep1=Sheep{name='DuoLi', age=5, color='白色'}
sheep2=Sheep{name='DuoLi', age=5, color='白色'}
sheep3=Sheep{name='DuoLi', age=5, color='白色'}

浅拷贝案例
在上面代码修改，在属性中多加个羊的朋友属性：

  1. 主方法
/**
 * @author yyx
 */
public class Sheep implements Cloneable {
    private String name;
    private int age;
    private String color;
    public Sheep friend;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getColor() {
        return color;
    }

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

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

    //使用默认的克隆方法
    @Override
    protected Object clone() {
        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sheep;
    }
}

2.测试类Client

/**
 * @author yyx
 */
public class Client {
    public static void main(String[] args) {
        Sheep sheep = new Sheep("DuoLi", 5, "白色");
        sheep.friend=new Sheep("haha",6,"黑色");
        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();

        System.out.println("sheep1=" + sheep1);
        System.out.println("sheep2=" + sheep2);
        System.out.println("sheep3=" + sheep3);

        System.out.println("sheep4="+sheep1+";sheep4 friend="+sheep1.friend.hashCode());
        System.out.println("sheep5="+sheep2+";sheep5 friend="+sheep2.friend.hashCode());
    }
}

运行结果如下所示：

sheep1=Sheep{name='DuoLi', age=5, color='白色'}
sheep2=Sheep{name='DuoLi', age=5, color='白色'}
sheep3=Sheep{name='DuoLi', age=5, color='白色'}
sheep4=Sheep{name='DuoLi', age=5, color='白色'};sheep4 friend=460141958
sheep5=Sheep{name='DuoLi', age=5, color='白色'};sheep5 friend=460141958

结论：
结论是克隆出来的羊并没有重新创建朋友对象，而是指向了原羊的朋友对象。

浅拷贝简述：
对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性复制一份给新的对象。
对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将成员变量的引用值（内存地址）复制了一份给新的对象。
浅拷贝是使用默认的clone()方法来实现的（sheep=(Sheep) super.clone();）

深拷贝案例
深拷贝实现方式1：重写clone方法来实现
深拷贝实现方式2：通过对象序列化来实现

方式一：重写clone方法实现
类DeepClone：

import java.io.Serializable;

/**
 * @author yyx
 */
public class DeepClone implements Cloneable, Serializable {
    private static final long serialVersionUID=1L;
    private String name;
    private String age;

    public DeepClone(String name, String age) {
        this.name = name;
        this.age = age;
    }

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

类DeepPrototype：

import java.io.Serializable;

/**
 * @author yyx
 */
public class DeepPrototype implements Cloneable, Serializable {
    String name;
    DeepClone deepClone;

    //方式一：使用clone方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep=null;
        deep=super.clone();
        //对引用数据类型的属性，进行单独处理
        DeepPrototype deepPrototype=(DeepPrototype)deep;
        deepPrototype.deepClone=(DeepClone) deepClone.clone();
        return deepPrototype;
    }
}

测试方法Client ：

/**
 * @author yyx
 */
public class Client {
    public static void main(String[] args) {
        DeepPrototype p=new DeepPrototype();
        p.name="haha";
        p.deepClone=new DeepClone("xixi","xixi.class");
        DeepPrototype p1 = null;
        try {
            p1= (DeepPrototype) p.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        System.out.println("name="+p.name+";deepClone="+p.deepClone.hashCode());
        System.out.println("name="+p1.name+";deepClone="+p1.deepClone.hashCode());
    }
}

运行结果如下所示：

name=haha;deepCloneableTarget=460141958
name=haha;deepCloneableTarget=1163157884

结论：可发现这样指向的就不是同一个内存地址了。但是如果有多个引用类型的属性，需要一个一个单独处理。

方式二：通过反序列化
DeepPrototype的克隆方法：

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * @author yyx
 */
public class DeepPrototype implements Cloneable, Serializable {
    String name;
    DeepClone deepClone;

//    //方式一：使用clone方法
//    @Override
//    protected Object clone() throws CloneNotSupportedException {
//        Object deep=null;
//        deep=super.clone();
//        //对引用数据类型的属性，进行单独处理
//        DeepPrototype deepPrototype=(DeepPrototype)deep;
//        deepPrototype.deepClone=(DeepClone) deepClone.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 deepPrototype = (DeepPrototype) ois.readObject();
            return deepPrototype;
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

测试方法Client ：

/**
 * @author yyx
 */
public class Client {
    public static void main(String[] args) {
        DeepPrototype p=new DeepPrototype();
        p.name="haha";
        p.deepClone=new DeepClone("xixi","xixi.class");

        DeepPrototype p2= (DeepPrototype) p.deepClone();
        System.out.println("name="+p.name+";deepCloneableTarget="+p.deepClone.hashCode());
        System.out.println("name="+p2.name+";deepCloneableTarget="+p2.deepClone.hashCode());
    }
}

运行结果如下所示：

name=haha;deepCloneableTarget=1020371697
name=haha;deepCloneableTarget=2094548358

结论：多个引用类型也是一次即可。

深拷贝注意事项：
创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时可能够提高效率。
如果原始对象发生变化（增加或者减少属性），其他克隆对象的也会发生相应的变化，无需修改代码。
在实现深克隆时可能需要比较复杂的代码。

总而言之：
对于一些复杂对象的创建，复制原型对象可能比使用构造函数创建实例更方便。
可以动态增加或减少产品类。由于创建产品类实例的方法是产品内部具有的，所以新增产品对整个结构没有影响。
可以利用深克隆的方式保存对象的状态，

不足：
需要为每一个类配备一个克隆方法，而且这个克隆方法需要对类的功能进行通盘考虑，这对全新的类来说不是很难，但对已有的类进行改造时，不一定是件容易的事，必须修改其源代码，违背了“开闭原则”。
实现深克隆时可能需要编写复杂的代


以上代码下载请点击该链接：https://github.com/Yarrow052/Java-package.git

Yarrow-Y
关注
Python设计模式之原型模式实例详解
12-25
设计模式——原型模式 原型模式(Prototype Pattern):用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象 原型模式是用场景:需要大量的基于某个基础原型进行微量修改而得到新原型时使用 """ fro
【设计模式】原型模式 ( 概念简介 | 使用场景 | 优缺点 | 基本用法 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
04-04 6010
I . 原型模式 概念简介 II . 原型模式 使用场景 III . 原型模式 优缺点 IV . 原型模式 实现及 简单示例
（7）原型模式
空杯
06-30 640
原型设计模式
设计模式使用场景实现示例及优缺点（创建型模式——原型模式）
最新发布
懒人w的博客
07-22 280
原型模式通过克隆现有对象来创建新对象，适用于对象创建成本高、初始化复杂或需要大量相似对象的场景。它能够简化对象创建过程，提高代码的灵活性和可维护性。
简述原型模型的特点_4种模型的优缺点
weixin_39880490的博客
12-21 5370
模型的优缺点瀑布模型有以下优点：1)为项目提供了按阶段划分的检查点。2)当前一阶段完成后，您只需要去关注后续阶段。3)可在迭代模型中应用瀑布模型。瀑布模型有以下缺点：1)在项目各个阶段之间极少有反馈。2)只有在项目生命周期的后期才能看到结果。3)通过过多的强制完成日期和里程碑来跟踪各个项目阶段。快速原型模型有以下优点1)克服瀑布模型的缺点，减少由于软件需求不明确带来的开发风险。快速原型模型有以下缺...
设计模式系列【15】：原型模式（原型设计模式）详解
单枪匹码
06-17 1238
在有些系统中，存在大量相同或相似对象的创建问题，如果传统的构造函数来创建对象，会比较复杂且耗时耗资源，用原型模式生成的对象就很高效，就像孙悟空拔下猴毛轻轻一吹就变出了很多孙悟空一样简单。 一、原型模式的定义与特点 原型（Prototype）模式是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供一种创建对象的最佳方式。用这种方式创建的对象非常高效，根本无须知道对象创建的细节。例如，Windows操作系统的安装通常较耗时，如果复制就快了很多。 用原型实例指定创建对象的种类，并通过拷
设计模式之原型模式
yihaoa的博客
12-01 541
文章目录一、克隆羊问题1.1 传统方式解决克隆羊问题1.2 代码1.3 传统方式的缺点二、原型模式2.1 原型模式基本介绍2.2 原型模式原理结构uml类图2.3 原型模式解决克隆羊问题的应用实例2.4 原型模式在Spring框架中源码分析三、深入讨论-浅拷贝和深拷贝3.1 浅拷贝介绍3.2 深拷贝基本介绍3.3 深拷贝应用实例四、原型模式的注意事项和细节 一、克隆羊问题 现在有一只羊 tom，姓...
Javascript设计模式之装饰者模式详解篇
11-28
JavaScript中的装饰者模式是一种设计模式，它允许在不修改原有对象的情况下动态地为对象添加新的功能。这种模式在软件工程中特别有用，因为它遵循开闭原则——对扩展开放，对修改关闭。装饰者模式的核心思想是通过将...
设计模式课程设计- 画 图 程 序.doc
03-27
《设计模式课程设计——画图程序》 设计模式是软件工程中的重要概念，它是一种解决常见问题的经验总结，能够帮助开发者构建可维护、可扩展的系统。在这个画图程序的课程设计中，我们将运用多种设计模式来实现一个...
Java和Android源码设计模式
03-18
#### 23种设计模式详解 设计模式通常分为三大类：创建型模式、结构型模式和行为型模式。 - **创建型模式**包括单例模式、工厂方法模式、抽象工厂模式、建造者模式和原型模式。这些模式关注于对象的创建机制，使...
Java设计模式
03-21
### Java设计模式详解 #### 一、设计模式概述 **设计模式**是在软件设计过程中针对常见问题而提出的标准化解决方案。这些模式是经过多年实践积累下来的，能够帮助开发者解决特定的设计问题，提高代码的可读性和可...
设计模式—原型模式(Prototype)
一起加油吧~
08-28 2284
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需知道任何创建的细节简单说就是先创建一个原型类实例，然后通过克隆的方法来复制一个一样的新对象，这个对象和原来的对象相同或相似核心：通过自带的Clone（）方法和ICloneable接口创建跟该对象相同的新对象，不需要知道具体的创建细节。就是具有相同的属性和功能的对象的抽象的集合。类名称首字母大写。多个单词则各个首字母大写；对外公开的方法需要用‘public’修饰符。
设计模式之原型模式详解（附应用举例实现）
pursuit的博客
04-22 8250
设计模式之原型模式详解（附应用举例实现）
设计模式第8讲——原型模式（Prototype）
让~学习~成为一种习惯（橡 皮 人の技术博客）
06-08 3758
原型模式属于创建型设计模式。 一、什么是原型模式 二、角色组成 三、优缺点 四、应用场景 4.1 生活场景 4.2 java场景 五、代码实现5.0 UML类图5.1 HeroSkill（英雄--具体原型类）5.2 StealManFactory（塞拉斯--客户端）5.3 TestPrototype六、总结
原型(克隆)模式
Filwaod
11-29 1772
原型模式的重心还是在创建新的对象实例，至于创建出来的对象，其属性的值是否一定要和原型对象属性的值完全一样，这个并没有强制规定，只不过在目前大多数实现中，克隆出来的对象和原型对象的属性值是一样的。原型模式可以在运行期间，由客户来注册符合原型接口的实现类型，也可以动态地改变具体的实现类型，看起来接口没有任何变化，但其实运行的已经是另外一个类实例了。克隆是手段，目的是生成新的对象实例。原型模式的客户端只知道原型接口的类型，并不知道具体的实现类型，从而减少了客户端对这些具体实现类型的依赖。
设计模式之原型模式详解
weixin_45538589的博客
08-16 438
设计模式之原型模式详解 文章目录设计模式之原型模式详解一、什么原型模式二、原型模式示例优点缺点三、注意 一、什么原型模式 原型模式 (Prototype Pattern) 是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象，属于创建型模式。原型模式的核心在于拷贝原型对象。以系统中已存在的一个对象为原型，直接基于内存二进制流进行拷贝，无需再经历耗时的对象初始化过程，当对象的构建过程比较耗时时，可以利用当前系统中已存在的对象作为原型，对其进行克隆。 二、原型模式示例 先创建一个原型IProto
Java 设计模式——原型模式
代码星辰的博客
07-22 1347
本文介绍了原型模式的相关知识。
设计模式-原型模式
BASK2311的博客
05-06 393
在原型模式中，我们首先创建一个原型对象，然后通过复制该对象来创建新的实例，新的对象实例不需要知道任何创建的细节，只需要知道如何复制即可得到一个与原型一模一样的新对象。这种方法比直接创建对象要快，因为在复制过程中不需要执行复杂的初始化操作。原型模式还可以减少代码重复，因为我们可以通过复制现有的对象来避免多次编写相同的创建代码。在实现原型模式时，我们通常使用一个原型管理器来存储原型对象。这个管理器允许我们在需要时获取原型对象的副本，而不是直接创建新对象。
Java 原型模式（Prototype Pattern）详解
小雨点的博客
06-10 607
Java 设计模式之原型模式
JavaEye：GOF设计模式详解——21种模式全面解析
本文档"21种设计模式详解-tony"由作者行者买刀提供，主要介绍了GOF设计模式中的21个经典模式，包括： 1. **工厂模式** (Factory): 该模式提供一个创建对象的接口，但让子类决定实例化哪个类。常用于对象的创建过程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值