Java的原型设计模式其实真的不难

目录
  • 原型设计模式
    • 1、原型设计模式的定义
    • 2、原型设计模式的优缺点
    • 3、原型模式的结构
    • 5、原型设计模式的简单代码实现
    • 6、原型设计模式的案例
    • 7、原型设计模式的应用场景
  • 总结

原型设计模式

我们知道在有些程序设计中,程序内有大量相同或相似对象的创建问题,如果用传统的构造函数或者重新去new来创建对象,会比较复杂且耗时耗资源,用原型模式生成对象就很高效。也就是我们当有一个原型的对象后,如果还需要一个或多个相同或者相似的对象,我们就也可以采用原型模式来设计。

举例说明:

在之前文章中讲的的可乐,我们知道可乐有很多配料,当刚研究出配方的时候我们去生产可乐,就需要往水里加各种各样的配料(相当于构造函数,然后传入参数),当之后才去生产可乐如果还是采用这种构造方法来生成的话,很麻烦且需要资源。我们把已经配好的作为一个可乐浓缩液,下次直接使用这个浓缩液就可以了(这就是原型设计模式里面的复制,直接复制浓缩液这个对象就可以)

1、原型设计模式的定义

用一个已经创建的实例作为原型,通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里,原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效,根本无须知道对象创建的细节。

类型: 创建型

2、原型设计模式的优缺点

优点:

1.Java 自带的原型模式基于内存二进制流的复制,在性能上比直接 new 一个对象更加优良

2.可以使用深克隆方式保存对象的状态,使用原型模式将对象复制一份,并将其状态保存起来,简化了创建对象的过程

缺点:

1.需要为每一个类都配置一个 clone 方法 (浅克隆

2.clone 方法位于类的内部,当对已有类进行改造的时候,需要修改代码,违背了开闭原则

3.当实现深克隆时,需要编写较为复杂的代码,而且当对象之间存在多重嵌套引用时,为了实现深克隆,每一层对象对应的类都必须支持深克隆,实现起来会比较麻烦。因此,深克隆、浅克隆需要运用得当

3、原型模式的结构

结构由三部分组成:

  • 抽象原型类:规定了具体原型对象必须实现的接口
  • 具体原型类:实现抽象原型类的 clone() 方法,它是可被复制的对象
  • 访问类:使用具体原型类中的 clone() 方法来复制新的对象

4、浅克隆和深克隆的区别

  • 浅克隆: 创建一个新对象,新对象的属性和原来对象完全相同,对于非基本类型属性,仍指向原有属性所指向的对象的内存地址
  • 深克隆: 创建一个新对象,属性中引用的其他对象也会被克隆,不再指向原有对象地址

5、原型设计模式的简单代码实现

首先我们先来一个简单的原型模式

有一个具体原型类:实现抽象原型类的 clone() 方法,它是可被复制的对象

/**
 *
 *具体原型类,需要实现Cloneable接口
 */
public class RealizeType implements Cloneable{

    RealizeType(){
        System.out.println("具体原型类创建成功");
    }

    public Object Clone() throws CloneNotSupportedException {
        System.out.println("具体原型类复制成功");
        return (RealizeType)super.clone();
    }
}

我们先来看一下需要实现Cloneable接口里面有什么?

其实这个接口里面什么都没有,只是一个代码规范而已

测试类:

/**
 * 测试类:
 * 第一个类对象通过new来创建
 * 第二个对象通过clone()的方法来创建
 * 最后判断两个对象地址是否一致
 */
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        RealizeType realizeType1 = new RealizeType();
        RealizeType realizeType2 = (RealizeType) realizeType1.Clone();
        boolean a = realizeType1==realizeType2;
        System.out.println("两个对象地址是否相等:" + a);

    }
}

如果两个对象的地址是一样的,说明没有复制成功,若地址不一样,则复制成功:

具体原型类创建成功具体原型复制成功两个对象地址是否相等:false

这样通过Clone()的方法复制了原型对象

6、原型设计模式的案例

公司里面每个阶段都会颁发荣誉,但是我们知道荣誉证书这个对象的模板已经确定好了,是固定不变的,我们只需要写入不同的信息即可:姓名、部门、获得的荣誉信息等等

奖状类:

/**
 * 奖状荣誉类:相当于具体原型类,可以被克隆使用
 */
public class Honor implements Cloneable{

    String Department; //部门
    String name; //姓名
    String info; //获奖信息

    //构造方法
    public Honor(String college, String name, String info) {
        this.Department = college;
        this.name = name;
        this.info = info;
    }

    //getset

    public String getCollege() {
        return Department;
    }

    public void setCollege(String college) {
        this.Department = college;
    }

    public String getName() {
        return name;
    }

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

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "奖状{" +
                "恭喜" + Department+
                "部门" + name  +
                "同志获得" + info +
                '}';
    }

    public Object clone() throws CloneNotSupportedException {
        System.out.println("荣誉拷贝成功!");
        return (Honor)super.clone();
    }
}

测试类:

public class test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Honor h1 = new Honor("销售部","张三","最佳销售");
        //第一个对象通过new来创建
        System.out.println(h1.toString());

        //通过clone来拷贝
        Honor h2 = (Honor) h1.clone();

        //更换名字
        h2.setName("李四");
        System.out.println(h2.toString());

        Honor h3 = (Honor) h1.clone();
        h3.setInfo("最佳员工");
        h3.setName("王五");
        h3.setCollege("人事部");
        System.out.println(h3.toString());

    }
}

输出:

奖状{恭喜销售部部门张三同志获得最佳销售}
荣誉拷贝成功!
奖状{恭喜销售部部门李四同志获得最佳销售}
荣誉拷贝成功!
奖状{恭喜人事部部门王五同志获得最佳员工}

通过原型设计模式的方法,我们在创建相似对象的时候,就不需要使用构造函数new一个新对象,通过clone的方法即可,也可以任意修改参数(使用get/set)

7、原型设计模式的应用场景

1.对象之间相同或相似,即只是个别的几个属性不同的时候

2.创建对象成本较大,比如初始化时间长,需要优化资源等

3.创建一个对象需要繁琐的数据准备或访问权限等,需要提高性能或者提高安全性

4.系统中大量使用该类对象,且各个调用者都需要给它的属性重新赋值

在Java框架Spring中原型设计模式应用的也很多,所以这个模式还是有很多用处的

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • Java 深入探讨设计模式之原型模式篇

    目录 传统方式 原型模式基本介绍 原型模式在spring框架中源码分析 深入讨论-浅讨论和深拷贝 原型模式的注意事项和细节 传统方式 克隆羊问题 现在有一只羊 tom,姓名为: tom,年龄为:1,颜色为:白色,请编写程序创建和 tom羊属性完全相同的10只羊. 传统方式解决克隆羊问题 思路分析(图解) 代码演示: public class Sheep { private String name; private int age; private String color; public She

  • Java设计模式之原型模式的示例详解

    目录 定义 案例 需求 方案一 方案二 对比分析 总结 定义 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象 即实现了一个原型接口,该接口用于创建当前对象的克隆,当直接创建对象的代价比较大时,则采用这种模式 案例 需求 张三要打印100000份照片 方案一 定义照片类 /** * 照片类 * @author:liyajie * @createTime:2022/2/15 11:47 * @version:1.0 */ @Data @AllArgsConstructor publi

  • Java 深入理解创建型设计模式之原型模式

    1.思考问题 现在有一只羊 tom,姓名为: tom,年龄为:1,颜色为:白色,请编写程序创建和 tom羊属性完全相同的10只羊. 按照传统的思路来,我们可能会按照下面的方式去写. 那么这种写法的优缺点自然而然就出来了: 优点是比较好理解,简单易操作. 缺点是在创建新的对象时,总是需要重新获取原始对象的属性,如果创建的对象比较复杂时,效率较低.总是需要重新初始化对象,而不是动态地获得对象运行时的状态,不够灵活. 改进的思路分析:Java中Object类是所有类的根类,Object类提供了一个 c

  • Java 超详细讲解设计模式之原型模式讲解

    目录 传统方式 原型模式基本介绍 原型模式在spring框架中源码分析 深入讨论-浅讨论和深拷贝 原型模式的注意事项和细节 传统方式 克隆羊问题 现在有一只羊 tom,姓名为: tom,年龄为:1,颜色为:白色,请编写程序创建和 tom羊属性完全相同的10只羊. 传统方式解决克隆羊问题 思路分析(图解) 代码演示: public class Sheep { private String name; private int age; private String color; public She

  • 深入理解Java设计模式之原型模式

    目录 一.前言 二.什么是原型模式 三.原型模式的适用场景 四.原型模式的实现 1.浅拷贝实现 2.深拷贝实现 五.总结 一.前言 单例模式可以避免重复创建消耗资源的对象,但是却不得不共用对象.若是对象本身也不让随意访问修改时,怎么办?通常做法是备份到副本,其它对象操作副本,最后获取权限合并,类似git上的PR操作. 二.什么是原型模式 原型模式用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象.需要注意的关键字是,新的对象,类没变..NET在System命名空间中提供了Cloneab

  • Java的原型设计模式其实真的不难

    目录 原型设计模式 1.原型设计模式的定义 2.原型设计模式的优缺点 3.原型模式的结构 5.原型设计模式的简单代码实现 6.原型设计模式的案例 7.原型设计模式的应用场景 总结 原型设计模式 我们知道在有些程序设计中,程序内有大量相同或相似对象的创建问题,如果用传统的构造函数或者重新去new来创建对象,会比较复杂且耗时耗资源,用原型模式生成对象就很高效.也就是我们当有一个原型的对象后,如果还需要一个或多个相同或者相似的对象,我们就也可以采用原型模式来设计. 举例说明: 在之前文章中讲的的可乐,

  • Java中的设计模式与7大原则归纳整理

    Java中的设计模式与7大原则: 一.创建型模式 1.抽象工厂模式(Abstract factory pattern): 提供一个接口, 用于创建相关或依赖对象的家族, 而不需要指定具体类. 2.生成器模式(Builder pattern): 使用生成器模式封装一个产品的构造过程, 并允许按步骤构造. 将一个复杂对象的构建与它的表示分离, 使得同样的构建过程可以创建不同的表示. 3.工厂模式(factory method pattern): 定义了一个创建对象的接口, 但由子类决定要实例化的类是

  • Java责任链设计模式

    责任链(Chain of Responsibility)模式是一种对象的行为模式.在责任链模式里,很多对象由每一个对象对其下家的引用而连接起来形成一条链.请求在这个链上 传递,直到链上的某一个对象决定处理此请求.发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求,这使得系统可以在不影响客户端的情况下动态 地重新组织和分配责任. 责任链模式属于行为型设计模式之一,怎么理解责任链?责任链是可以理解成数个对象首尾连接而成,每一个节点就是一个对象,每个对象对应不同的处理逻辑,直至有一个对象响应

  • Java装饰器设计模式_动力节点Java学院整理

    定义: 动态给一个对象添加一些额外的职责,就象在墙上刷油漆.使用Decorator模式相比用生成子类方式达到功能的扩充显得更为灵活.设计初衷:通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态的. 要点: 装饰者与被装饰者拥有共同的超类,继承的目的是继承类型,而不是行为 实际上Java 的I/O API就是使用Decorator实现的. //定义被装

  • PHP设计模式之原型设计模式原理与用法分析

    本文实例讲述了PHP设计模式之原型设计模式原理与用法.分享给大家供大家参考,具体如下: 一.什么是原型设计模式 原型设计模式使用一种克隆技术来复制实例化的对象,新对象是通过复制原型实例创建的.原型设计模式的目的是通过使用克隆以减少 实例化对象的开销. 在原型设计模式中,Client类是不可缺少的一部分. PHP有一个内置的克隆方法__clone()可以在设计模式中使用,但是不能直接访问,使用clone关键字即可.克隆不会启动构造函数. 二.什么时候使用原型设计模式 如果一个项目要求你创建某个原型

  • Java责任链设计模式实例分析

    本文实例讲述了Java责任链设计模式.分享给大家供大家参考,具体如下: 一 代码 abstract class AbstractHandler { private Handler Handler = null;// 持有责任链中下一个责任处理者的引用 public void setHandler( Handler handler ) { this.Handler = handler; } public Handler getHandler() { return Handler; } } inte

  • Java使用原型模式展现每日生活应用案例详解

    本文实例讲述了Java使用原型模式展现每日生活.分享给大家供大家参考,具体如下: 一.模式定义 用原型实例指定创建对象的种类,并且通过复制这些原型创建新的对象. 二.模式举例 1 模式分析 我们借用每日上班情景耒说明这一模式. 2 故事情节分析图 3 原型模式静态建模 4 代码示例 4.1 原型建立 package com.prototype.pojo; /** * 日常生活类 * * @author * */ public class DayLife implements Cloneable

  • Java多例设计模式实例详解

    本文实例讲述了Java多例设计模式.分享给大家供大家参考,具体如下: 一.多例设计模式定义 多例设计模式就是存在多个对象实例,供外部应用裯用,比喻数据库连接池. 二.多例模式静态类图 三.多例模式代码实现 1. 多例模式核心类 package com.demo.multipleton; import java.util.ArrayList; /** * 多例模式 * * @author * */ public class Multipleton { // 多例数量 private static

  • Java通俗易懂系列设计模式之模板模式

    实际开发中常常会遇到,代码骨架类似甚至相同,只是具体的实现不一样的场景.例如:流程都有开启.编辑.驳回.结束.每个流程都包含这几个步骤,不同的是不同的流程实例它们的内容不一样.共享单车都是先开锁.骑行.上锁.付款.这些大的步骤固定,不同的是每个实例的具体实现细节不一样.这些类似的业务我们都可以使用模板模式实现.为什么要使用模板模式以及如何使用呢? 介绍 定义:在模板模式(Template Pattern)中,一个抽象类公开定义了执行它的方法的方式/模板.它的子类可以按需要重写方法实现,但调用将以

随机推荐