精华内容
下载资源
问答
  • 工厂模式概念及其使用场景
    千次阅读
    2022-03-29 10:19:59

    1.工厂创建型模式亦称虚拟构造函数、Virtual Constructor、Factory Method

    工厂方法模式是一种创建型设计模式, 其在父类中提供一个创建对象的方法, 允许子类决定实例化对象的类型。

    2.使用场景
    工厂方法模式适合应用场景
    当你在编写代码的过程中, 如果无法预知对象确切类别及其依赖关系时, 可使用工厂方法。

    工厂方法将创建产品的代码与实际使用产品的代码分离, 从而能在不影响其他代码的情况下扩展产品创建部分代码。

    例如, 如果需要向应用中添加一种新产品, 你只需要开发新的创建者子类, 然后重写其工厂方法即可。

    如果你希望用户能扩展你软件库或框架的内部组件, 可使用工厂方法。

    继承可能是扩展软件库或框架默认行为的最简单方法。 但是当你使用子类替代标准组件时, 框架如何辨识出该子类?

    解决方案是将各框架中构造组件的代码集中到单个工厂方法中, 并在继承该组件之外允许任何人对该方法进行重写。

    让我们看看具体是如何实现的。 假设你使用开源 UI 框架编写自己的应用。 你希望在应用中使用圆形按钮, 但是原框架仅支持矩形按钮。 你可以使用 圆形按钮Round­Button子类来继承标准的 按钮Button类。 但是, 你需要告诉 UI框架UIFramework类使用新的子类按钮代替默认按钮。

    为了实现这个功能, 你可以根据基础框架类开发子类 圆形按钮 UIUIWith­Round­Buttons , 并且重写其 create­Button创建按钮方法。 基类中的该方法返回 按钮对象, 而你开发的子类返回 圆形按钮对象。 现在, 你就可以使用 圆形按钮 UI类代替 UI框架类。 就是这么简单!

    如果你希望复用现有对象来节省系统资源, 而不是每次都重新创建对象, 可使用工厂方法。

    在处理大型资源密集型对象 (比如数据库连接、 文件系统和网络资源) 时, 你会经常碰到这种资源需求。

    让我们思考复用现有对象的方法:

    首先, 你需要创建存储空间来存放所有已经创建的对象。
    当他人请求一个对象时, 程序将在对象池中搜索可用对象。
    …然后将其返回给客户端代码。
    如果没有可用对象, 程序则创建一个新对象 (并将其添加到对象池中)。
    这些代码可不少! 而且它们必须位于同一处, 这样才能确保重复代码不会污染程序。

    可能最显而易见, 也是最方便的方式, 就是将这些代码放置在我们试图重用的对象类的构造函数中。 但是从定义上来讲, 构造函数始终返回的是新对象, 其无法返回现有实例。

    因此, 你需要有一个既能够创建新对象, 又可以重用现有对象的普通方法。 这听上去和工厂方法非常相像。

    更多相关内容
  • 少于200行的现代c ++对象工厂实现 :package: :factory: 我需要一个易于使用,易于模拟的c ++工厂库(可用于依赖注入),而快速搜索并没有得到我想要的东西。 因此,我建立了这个。 阅读API文档-()-()。 概念 ...
  • 什么是面向对象 顾名思义,就是和对象面对面,关注于对象 面向对象是一种编程思想,不是语法 我们一般写的代码是通过逻辑分析,先做什么,再做什么,关注到其中的每一个过程 – ...工厂函数创建对象有一个缺点,就是不
  • 主要介绍了Javascript面向对象程序设计工厂模式,结合实例形式分析了《javascript设计模式》中Javascript面向对象工厂模式相关概念、原理、用法及操作注意事项,需要的朋友可以参考下
  • Todo JS是一个JavaScript项目,旨在展示对诸如对象工厂函数,模块模式和OOP之类JavaScript概念的理解。 该项目还说明了“单一责任”和“紧密耦合对象”的概念。 使用Webpack可以很好地将代码库结构化为不同的模块...
  • 面向对象编程基本概念

    千次阅读 2018-04-18 15:41:53
    引言 在软件工程的早期,史诗...今天大多数项目都使用面向对象概念。由于C ++引入了OOP,因此用户体验已经产生了关于如何最好地利用OOP的更多知识。有很多关于面向对象的协议和更多的争论。应该鼓励哪些功能? C ...

    引言

     在软件工程的早期,史诗般的挣扎着项目的复杂性,增长以及管理大型开发团队的挑战。面向对象编程(OOP)为软件社区引入了一场革命,以帮助解决这些问题。 OOP专注于模块化,改变容忍度,代码重用,易于理解和分布式开发。今天大多数项目都使用面向对象的概念。

    由于C ++引入了OOP,因此用户体验已经产生了关于如何最好地利用OOP的更多知识。有很多关于面向对象的协议和更多的争论。应该鼓励哪些功能? C ++是否定义了哪些功能是面向对象的。

    随着重用和验证IP在硬件验证中变得流行,OOP是适用的。事实上,功能验证为重用提供了理想的条件,因为标准协议,系统甚至测试和有趣的事务序列都利用了OOP。

    设计大型软件应用程序

     传统上,程序被视为一系列功能的集合。这适用于小型应用程序,但阻碍重用程序的一个子集或利用分布式并行开发过程,其中不同的工程师拥有程序的不同方面。那么我们如何设计一个大型应用程序呢? OOP建议使用“分而治之”的方法,其中应用程序是一组相关的交互对象。例如,模拟交通的应用程序将涉及汽车,司机和交通信号灯,而不是为整个交通系统设计应用程序,我们应该专注于单独的模块以捕捉汽车,司机和交通灯操作。测试平台或验证项目也是如此。我们专注于最终构成测试平台的数据项或协议特定组件,而不是专注于完整的应用程序。

    OOP中的对象是什么?

     一个对象是一个实体,它拥有的数据和对这些数据进行操作的方法。每个对象都可以被看作是一个独立的小机器或者具有不同责任的角色。在我们的交通仿真例子中,汽车,司机和交通灯都是对象。

     分布式开发环境

     OOP面临的挑战之一是定义对象和它们之间的交互。最初的协议是让个人和团队合作的关键。这些对象通过商定的公共接口(合同)提供服务。其他对象可以使用这个公共API。对象内部实现可以独立开发和完善。语言提供信息隐藏设施,以限制对象使用公共方法。下图演示了两个在OOP环境中工作的开发人员,使用单独对象之间的协议接口。


                           OOP接口对象启用并行开发

    分离问题

     我们可以使用相同的对象来创建其他系统吗?或复制一个对象并将其用于不同的系统?这需要建立独立的对象。对象之间不应存在功能重叠。例如,我们的交通仿真例子也可能包括一条赛道。在一个典型的赛道上,没有交通信号灯,没有转向灯,而且赛车速度更快。如果一辆汽车的实施假定存在交通灯,则不能参与没有交通信号灯的赛道系统。同样,一个功能验证示例可以拥有一个不应该自行发送或提交给特定协议/驱动程序的数据包。如果是这样,它不能用于需要不同驱动协议或协议分层的环境中。

     类,对象和程序

     类定义了对象的抽象特征(属性)和行为(方法)。这是一个蓝图,允许创建一个或多个相同类型的对象。例如,可能有一个汽车类定义了汽车对象可以包含的所有东西。然后,一辆特殊的汽车,比如...... Plorsche,是汽车类的一个子类(专业化),具有超越普通汽车类的特殊属性。最后,汽车物体是具有特定颜色和引擎属性的汽车的特定实例,例如银色Plorsche轿跑车。可能有许多Plorsche汽车共享这些属性;所有这些都将成为Plorsche子类或汽车专业化的对象。

    对象保存运行时数据并用作程序的构建块。程序或应用程序实例化对象并触发它们的交互。


     注: SystemVerilog类与动态特性的Verilog模块实例不同。模块实例,它们的编号和层次结构是在Verilog中进行阐述时创建的,并且在整个模拟过程中都是静态的。对象可以在运行时根据请求创建。这允许创建模块化和优化的数据结构。在功能验证中,测试平台的构建过程是动态的,这使得它更加灵活。它使用程序流控制来实例化所需的测试台结构。根据需要,动态对象用于表示数据项(如数据包,帧或事务),并且通常会考虑其他环境变量值

     使用泛化和继承

     人类使用泛化来感知世界。汽车的抽象概念意味着:四个车轮,一个发动机,至少两个车门,一个方向盘等等。这种抽象能力使我们能够组织数据并实现有效的沟通。例如,你可以说“我开车让我的车昨天工作”,听众不需要你定义一辆车,谈论你驾驶的特定汽车,或者你驾驶的方式。这些细节是不必理解你简单陈述的意图

     面向对象编程使我们能够在软件设计中做同样的事情。您可以定义泛型类的概念,并使用继承来创建该抽象类的特化。跑车可能是通用汽车概念的专业化。除了拥有所有的汽车属性外,它还具有更大的马力,更好的操控性,并且经常吸引人们的注意力。用户可以表达所需的功能 - 例如,驾驶()汽车 - 而无需知道特定汽车中驾驶方式的具体细节。

    使用继承允许具有足够类似接口的对象共享实现代码。一个永远不应该实例化的父类 - 意味着它仅用于建模目的以便重用和抽象 - 被声明为一个虚类.


    创建紧凑可重用代码

     如果您在对象之间有重叠,请考虑创建一个抽象类来保存通用功能并派生一个类来捕获变体。这将减少开发和维护所需的代码量。例如,请求和响应数据包可能具有相似的属性,但请求中生成的数据是在响应中收集的,反之亦然。



    OOP中的多态

     程序可能需要以程序的方式操纵一组对象。例如,您可能想要一个汽车的抽象句柄,并在一个循环中调用数组中所有汽车的run()方法。每个汽车类都有不同的run()方法实现。对抽象类执行run()并执行特定run()的能力称为“多态性”。程序员不必提前知道对象的确切类型。下面的例子3-2演示了Plorsche和Flerrari汽车是如何从一个抽象运动车类派生的。多态性允许程序的print()任务持有一个指向可能包含Plorsche和Flerrari汽车的虚拟类数组的指针,但为每个项目执行正确的print()函数

     例3-2继承和多态


    Downcast

     想象一下,一辆具有飞行能力的新车被发明出来,而其他车辆则无法飞行。一个汽车使用者不希望发现他们的汽车在驶入鸿沟后不能飞行。在开始驾驶之前需要提前警告,以确保您的汽车能够飞行。在这种情况下,您需要在模拟开始之前获得编译时错误消息。例如,您不希望非法分配在执行两天后中断仿真。编译器强制用户在使用其一个子类型特征或属性之前明确地向下转换泛型引用。 (术语向下意味着在继承树中下降。)

    注:在我们的汽车示例中,用户需要明确声明指针用fly()方法持有汽车。将通用句柄分配给特定的句柄称为downcast。


    类库

     类库是用于加快系统实现的类的集合。用户可以通过定制它们来从库类派生新的类,或者只是实例化和使用它们,而不是从头开始实现。例子包括数学图书馆,图形图书馆,甚至是面向验证的图书馆。 UVM有一个类库。类库的一个重要优点是它编写了最佳实践并实现了标准化和重用。使用类库的缺点是需要学习类库规范。虽然类库带有API规范,但通过类库实现并了解功能和建议的实现是一种很好的做法。

    静态方法和属性

     对象具有保存其特定数据和状态的属性。例如,一个Plorsche状态可以被“驱动”,而一个不同的Plorsche可以被“停放”。但是,SystemVerilog支持属于一个类而不是特定实例的静态属性。即使没有实例存在,也可以访问这些属性,并允许多实例预订和设置。例如,您可以使用静态属性来计算特定类的实例数量。您也可以拥有可以操纵静态属性的静态方法。静态方法不能访问非静态属性,因为这些属性可能不存在。

    调用静态方法不涉及特定的实例,可以通过使用class_name :: method_name()来实现。 例如,我们可以使用这样的汽车静态方法:car::increment_counter()

    参数化类

     当需要用于不同数据类型或大小的类似逻辑时,使用参数化类。参数化类的经典用法适用于容器。以下示例显示了不同类型对象的容器。


    包和命名空间

     典型的应用程序利用来自多个来源的许多类。有可能某些类型,类或函数名称可能会发生冲突并导致编译错误。修改类和类型名称以获得唯一性的成本可能很大。此外,当使用加密的代码时,如验证IP(VIP),这个问题更具挑战性。

    为了避免全局名称空间发生冲突,面向对象的语言将添加包或名称空间功能。这为每个包定义创建了一个不同的范围。在不存在冲突的情况下,用户可以使用import命令将所有定义导入联合名称空间。如果存在冲突并且不可能包含导入,则用户可以导入特定类型或使用类的完全限定类型名称(包名称和类名称的组合)。

    例如,假设在我们的系统中,开发了两种类型的汽车类别(sports_car),一种是品牌A,另一种是品牌Z.没有包装,两个类别称为“sports_car”(来自品牌A和品牌Z各一个)无法编译

    在以下示例中,我们将包导入单个模块范围。 这是可能的,因为在包内与名称没有冲突。 您可以导入包中的所有符号,或者只使用不碰撞的选定符号。


     为所有可重用代码使用包至关重要,以便与其他包中的其他类似类共存并防止代码修改。

    软件设计模式

     软件问题的创造性解决方案可以产生随机的好处和后果。另外,已经证实的解决方案可以产生更一致的结果我们不反对创造力,但大多数验证挑战需要创造性和常识性,而不需要重新发明轮子。设计模式是软件设计中常见问题的一般可重复解决方案。 1995年出版的“设计模式:可重用面向对象软件的元素”(通常被称为“四人帮”或“GoF”一书)一书创造了术语设计模式,并成为面向对象的软件的重要来源,面向设计理论与实践。这些最为人所知的做法是在包含姓名,挑战,代码样本等的模板中捕获的。有关更多信息,请阅读Gamma,Helm,Johnson和Vlissides的“设计模式:可重用面向对象软件的元素”一书。

    软件设计模式:单例模式

    许多系统都要求系统资源只应该实例化一次。这可能是内存管理员,全球协调员或其他系统级协调员。问题是如何创建一个具有内置限制的类只能实例化一次?单例解决方案通过使构造函数专用于类来工作,从而防止类被实例化。实例化类的唯一方法是调用静态方法,该方法在首次调用时分配类的本地实例并返回调用者的对象句柄。对此静态方法的连续调用将返回实例化的实例句柄,而不分配新的类。 UVM库中的单例的一个示例是报告服务器具有受保护的构造函数,以将服务器的创建限制为单个实例

    软件设计反模式

     反模式,也称为陷阱,通常是对问题的不良软件解决方案进行彻底改造。这个词是由安德鲁柯尼希1995年创造的,受到了四人帮的启发。使用不良做法有多种原因。在某些情况下,它涉及缺乏计划;在其他情况下,在错误的情况下使用完美的解决方案,使其适得其反。与设计模式一样,反模式具有正式的模板,其名称,原因,含义等等。反模式还包括恢复过程(重构)以修补误用的实践。反模式的一个例子是“意大利面条”代码 - 源代码,它具有复杂和纠结的控制结构。有关更多信息,请阅读Brown,Marley,McCormick和Mowbray撰写的书籍“AntiPatterns:危机中的软件重构,体系结构和项目”

    为什么现有的面向对象方法不够?

     上面提到的是一些书籍,它们记录了多年来在面向对象编程方面积累和证实的经验。那么,为什么我们需要更多的方法?大多数通用概念适用于功能验证任务并且有效。但功能验证引入了独特的挑战,并且与软件开发不同。与每六个月发布的程序相反,功能验证的结果是最终测试,其中几项可能会在一天内创建。考虑下图中的测试平台以及使用它的三个测试。每个测试涉及测试平台的不同方面。它可能会改变配置,引入不同的序列,在生成的数据项上使用约束等来实现其目标。面向对象的编程不是为了这样的极端重用,也没有考虑到通过测试进一步修改类的开放性。


    面向方面的编程

     最近,软件设计模式已被批评为建议复杂的配方,而不是改进工具或语言。 OOPSLA(面向对象的程序设计,系统,语言和应用)是一个主要在美国举行的年度ACM会议,它主持了一个名为“四人帮”试验的小组。 Verisity引入了e语言来解决验证挑战,并使用这种内置解决方案而非设计模式。在面向方面的特性e面(这是面向对象的超集)的基础上,面向方面的编程提供了许多SystemVerilog语言限制的简单解决方案。在SystemVerilog UVM中,我们使用工厂解决方案,回调,字段宏,配置机制等等。在这些不是必需的。此外,e允许其他功能,例如覆盖范围和枚举类型扩展,用于数据项随机化的更强大的建模功能以及显着简化验证任务的其他语言功能。该行业在向其他HVL提供有限的AOP扩展方面做出了一些努力,但这些扩展受到限制,并且无法理解挑战和解决方案。我们只能希望SystemVerilog能够在某些时候采用这些功能并简化验证工作,从而为SystemVerilog用户群带来益处

    概要

     面向对象编程引入了一种处理大型软件应用程序复杂性的方法。它侧重于模块化,适应变化和重用,这是功能验证的关键。了解理论和动机是有益的,但是没有必要为了使用UVM库而掌握理论。使用UVM库的优点之一是它将最好的验证实践编入库基类,使您能够按照推荐的指示完成正确的事情

    展开全文
  • Java程序设计(面向对象)- 基本概念

    万次阅读 多人点赞 2019-05-25 20:10:06
    所谓对象就是真实世界中的实体,对象与实体是一一对应的,也就是说现实世界中每一个实体都是一个对象,它是一种具体的概念。 定义:以基于对象的思维去分析和解决问题,万物皆对象 对象有以下特点: 对象具有...

    在这里插入图片描述Java 是面向对象的编程语言,对象就是面向对象程序设计的核心。所谓对象就是真实世界中的实体,对象与实体是一一对应的,也就是说现实世界中每一个实体都是一个对象,它是一种具体的概念。

    定义:以基于对象的思维去分析和解决问题,万物皆对象

    对象有以下特点:

    • 对象具有属性和行为。
    • 对象具有变化的状态。
    • 对象具有唯一性。
    • 对象都是某个类别的实例。
    • 一切皆为对象,真实世界中的所有事物都可以视为对象。

    对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。
    类:类是一个模板,它描述一类对象的行为和状态。

    类的基本结构

    属性:对象数据的描述
    方法:对象的行为
    构造方法:用于实例化对象
    内部类:在类中声明的类(inner class)
    块:分静态块与实例块
    类的声明:(访问权限修饰符public.default(可忽略不写,为默认))(修饰final.abstract.synchronized)class 类名{ 类体 }
    类的作用:类就是一个模板,定义多个对象共同的属性和方法 如:学生类(张三,李四) 手机类(华为.oppo)

    属性

    属性可理解为对象的数据。注:属性有称成员变量,是声明在类中的变量,在方法体中声明的变量称为局部变量或临时变量。
    声明方式:(访问权限修饰符)(修饰符)数据类型 属性名(=初值)
    例如:
    在这里插入图片描述

    变量

    • 局部变量:在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。
    • 成员变量:成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
    • 类变量:类变量也声明在类中,方法体之外,但必须声明为static类型。

    方法

    方法即对象的行为,为定义在类中的具特定功能的一段独立的小程序,方法也称为函数
    方法运行后的返回结果的数据类型,如果没有返回值使用void
    声明形式:

    (访问权限修饰符)(修饰符)返回值数据类型  方法名(形式参数列表){
                执行语句;
           return;                      
           }
    
    • 参数类型: 形式参数的数据类型
    • 形式参数:就是一个变量,用于存储调用方法时传递给方法的实际参数
      return 用于结束方法
    • 返回值:该方法执行后的结果,该结果会返回给调用者
    • 方法的特点:
      定义方法可以将功能代码进行封装。
      便于该功能进行复用。 方法只有被调用才会被执行。
      方法的出现提高代码的复用性。
      方法若没有返回值,则用关键字void表示,那么该方法中的return语句如果在最后一行可以省略不写。
      方法中可以调用方法,不可以在方法内部定义方法。
      定义方法时,方法的结果应返回给调用者,交由调用者来处理.

    方法的重载

    方法名相同、参数不同(数量不同、类型不同、顺序不同)、同一作用域。
    在这里插入图片描述

    构造方法(构造器)

    要想使用Java类,必须创建类的对象,即对类进行实例化。而创建对象就必须使用构造方法。因此,构造方法几乎是一个类必须有的元素。
    构造方法的作用:

    • 1.为了初始化成员属性,而不是初始化对象,初始化对象是通过new关键字实现的
    • 2.通过new调用构造方法初始化对象,编译时根据参数签名来检查构造函数,称为静态联编和编译多态(参数签名:参数的类型,参数个数和参数顺序)
    • 3.创建子类对象会调用父类构造方法但不会创建父类对象,只是调用父类构造方法初始化父类成员属性;如下图,对一个银行卡账号的设计:
      在这里插入图片描述在这里插入图片描述

      类与类之间的关系

      • 一、继承关系 继承指的是一个类(称为子类、子接口)继承另外的一个类(称为父类、父接口)的功能,并可以增加它自己的新功能的能力。在Java中继承关系通过关键字extends明确标识,在设计时一般没有争议性。在UML类图设计中,继承用一条带空心三角箭头的实线表示,从子类指向父类,或者子接口指向父接口。
        在这里插入图片描述
    • 二、实现关系 实现指的是一个class类实现interface接口(可以是多个)的功能,实现是类与接口之间最常见的关系。在Java中此类关系通过关键字implements明确标识,在设计时一般没有争议性。在UML类图设计中,实现用一条带空心三角箭头的虚线表示,从类指向实现的接口。
      在这里插入图片描述
    • 三、依赖关系 简单的理解,依赖就是一个类A使用到了另一个类B,而这种使用关系是具有偶然性的、临时性的、非常弱的,但是类B的变化会影响到类A。比如某人要过河,需要借用一条船,此时人与船之间的关系就是依赖。表现在代码层面,为类B作为参数被类A在某个method方法中使用。在UML类图设计中,依赖关系用由类A指向类B的带箭头虚线表示。
      在这里插入图片描述
    • 四、关联关系 关联体现的是两个类之间语义级别的一种强依赖关系,比如我和我的朋友,这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的,一般是长期性的,而且双方的关系一般是平等的。关联可以是单向、双向的。表现在代码层面,为被关联类B以类的属性形式出现在关联类A中,也可能是关联类A引用了一个类型为被关联类B的全局变量。在UML类图设计中,关联关系用由关联类A指向被关联类B的带箭头实线表示,在关联的两端可以标注关联双方的角色和多重性标记。
      在这里插入图片描述
    • 五、聚合关系 聚合是关联关系的一种特例,它体现的是整体与部分的关系,即has-a的关系。此时整体与部分之间是可分离的,它们可以具有各自的生命周期,部分可以属于多个整体对象,也可以为多个整体对象共享。比如计算机与CPU、公司与员工的关系等,比如一个航母编队包括海空母舰、驱护舰艇、舰载飞机及核动力攻击潜艇等。表现在代码层面,和关联关系是一致的,只能从语义级别来区分。在UML类图设计中,聚合关系以空心菱形加实线箭头表示。
      在这里插入图片描述
    • 六、组合关系 组合也是关联关系的一种特例,它体现的是一种contains-a的关系,这种关系比聚合更强,也称为强聚合。它同样体现整体与部分间的关系,但此时整体与部分是不可分的,整体的生命周期结束也就意味着部分的生命周期结束,比如人和人的大脑。表现在代码层面,和关联关系是一致的,只能从语义级别来区分。在UML类图设计中,组合关系以实心菱形加实线箭头表示。
      在这里插入图片描述
    • 七、总结 对于继承、实现这两种关系没多少疑问,它们体现的是一种类和类、或者类与接口间的纵向关系。其他的四种关系体现的是类和类、或者类与接口间的引用、横向关系,是比较难区分的,有很多事物间的关系要想准确定位是很难的。前面也提到,这四种关系都是语义级别的,所以从代码层面并不能完全区分各种关系,但总的来说,后几种关系所表现的强弱程度依次为:组合>聚合>关联>依赖。

    Java 消息服务

    Java消息服务指的是两个应用程序之间进行异步通信的API,它为标准消息协议和消息服务提供了一组通用接口,包括创建、发送、读取消息等,用于支持JAVA应用程序开发。在J2EE中,当两个应用程序使用JMS进行通信时,它们之间并不是直接相连的,而是通过一个共同的消息收发服务连接起来,可以达到解耦的效果。

    • 优点
      异步:JMS天生就是异步的,客户端获取消息的时候,不需要主动发送请求,消息会自动发送给可用的客户端。
      可靠:JMS保证消息只会递送一次。大家都遇到过重复创建消息问题,而JMS能帮你避免该问题。

    JMS消息传送模型

    • 点对点消息传送模型
      在点对点消息传送模型中,应用程序由消息队列,发送者,接收者组成。每一个消息发送给一个特殊的消息队列,该队列保存了所有发送给它的消息(除了被接收者消费掉的和过期的消息)。点对点消息模型有一些特性,如下:

      • 每个消息只有一个接收者;
      • 消息发送者和接收者并没有时间依赖性;
      • 当消息发送者发送消息的时候,无论接收者程序在不在运行,都能获取到消息;
      • 当接收者收到消息的时候,会发送确认收到通知(acknowledgement)。
    • 发布/订阅消息传递模型
      在发布/订阅消息模型中,发布者发布一个消息,该消息通过topic传递给所有的客户端。在这种模型中,发布者和订阅者彼此不知道对方,是匿名的且可以动态发布和订阅topic。topic主要用于保存和传递消息,且会一直保存消息直到消息被传递给客户端。
      发布/订阅消息模型特性如下:

      • 一个消息可以传递给多个订阅者
      • 发布者和订阅者有时间依赖性,只有当客户端创建订阅后才能接受消息,且订阅者需一直保持活动状态以接收消息。
      • 为了缓和这样严格的时间相关性,JMS允许订阅者创建一个可持久化的订阅。这样,即使订阅者没有被激活(运行),它也能接收到发布者的消息。

      接收消息

    • 同步
       使用同步方式接收消息的话,消息订阅者调用receive()方法。在receive()中,消息未到达或在到达指定时间之前,方法会阻塞,直到消息可用。

    • 异步
       使用异步方式接收消息的话,消息订阅者需注册一个消息监听者,类似于事件监听器,只要消息到达,JMS服务提供者会通过调用监听器的onMessage()递送消息。

      JMS编程接口

      JMS应用程序由如下基本模块组成:

      • 管理对象(Administered objects)-连接工厂(Connection Factories)和目的地(Destination)
      • 连接对象(Connections)
      • 会话(Sessions)
      • 消息生产者(Message Producers)
      • 消息消费者(Message Consumers)
      • 消息监听者(Message Listeners)
        在这里插入图片描述
        JMS消息结构:消息头、消息属性、消息体。

    Java设计基础及面向对象导向

    展开全文
  • 主要介绍了PHP面向对象程序设计之对象生成方法,简单介绍了php常见对象生成模式并结合实例形式分析了php对象生成的单例模式、工厂模式、原形模式等概念与实现技巧,需要的朋友可以参考下
  • 一、工厂模式概念 工厂模式定义一个用于创建对象的接口,这个接口由子类决定实例化哪一个类。该模式使一个类的实例化延迟到了子类。而子类可以重写接口方法以便创建的时候指定自己的对象类型(抽象工厂)。 这个模式...
  • 一、工厂模式概念 工厂模式定义一个用于创建对象的接口,这个接口由子类决定实例化哪一个类。该模式使一个类的实例化延迟到了子类。而子类可以重写接口方法以便创建的时候指定自己的对象类型(抽象工厂)。 这个模式...
  • 首先我们先引用些概念工厂模式:专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有其同的父类。工厂模式属于类的创建模式,通常根据自变量的不同返回不同类的实例。 工厂模式的实质是由一个工厂类...
  • 我们来看看概念,“所谓工厂函数,就是指这些内建函数都是类对象,当你调用他们时,实际上是创建了一个类实例”。意思就是当我调用这个函数,实际上是先利用类创建了一个对象,然后返回这个对象。由于Javascript本身...
  • 工厂模式将目的将创建对象的具体过程屏蔽隔离起来,从而达到更高的灵活性,工厂模式可以分为三类:简单工厂模式、工厂方法模式、抽象工厂模式;简单工厂模式的核心是定义一个创建对象的接口,将对象的创建和本身的...

            在面向对象编程中,创建对象实例最常用的方式就是通过 new 操作符构造一个对象实例,但在某些情况下,new 操作符直接生成对象会存在一些问题。举例来说,对象的创建需要一系列的步骤:可能需要计算或取得对象的初始位置、选择生成哪个子对象实例、或在生成之前必须先生成一些辅助对象。 在这些情况,新对象的建立就是一个 “过程”,而不仅仅是一个操作,就像一部大机器中的一个齿轮传动。

            针对上面这种情况,我们如何轻松方便地构造对象实例,而不必关心构造对象示例的细节和复杂过程?解决方案就是使用一个工厂类来创建对象。

    一、什么是工厂模式:

            工厂模式将目的将创建对象的具体过程屏蔽隔离起来,从而达到更高的灵活性,工厂模式可以分为三类:

    • 简单工厂模式(Simple Factory)
    • 工厂方法模式(Factory Method)
    • 抽象工厂模式(Abstract Factory)

    这三种模式从上到下逐步抽象,并且更具一般性。《设计模式》一书中将工厂模式分为两类:工厂方法模式与抽象工厂模式。将简单工厂模式看为工厂方法模式的一种特例,两者归为一类。 我们先从以下案例对工厂模式做个初步的了解:

    (1)在没有工厂的时代,如果客户需要一款宝马车,那么就需要客户去创建一款宝马车,然后拿来用。

    (2)简单工厂模式:后来出现了工厂,用户不再需要去创建宝马车,由工厂进行创建,想要什么车,直接通过工厂创建就可以了。比如想要320i系列车,工厂就创建这个系列的车。

    (3)工厂方法模式:为了满足客户,宝马车系列越来越多,如320i、523i等等系列,一个工厂无法创建所有的宝马系列,于是又单独分出来多个具体的工厂,每个具体工厂创建一种系列,即具体工厂类只能创建一个具体产品。但是宝马工厂还是个抽象,你需要指定某个具体的工厂才能生产车出来。

    (4)抽象工厂模式:随着客户要求越来越高,宝马车必须配置空调,于是这个工厂开始生产宝马车和需要的空调。最终是客户只要对宝马的销售员说:我要523i空调车,销售员就直接给他523i空调车了。而不用自己去创建523i空调车宝马车。

    下面我们就针对几种不同的工厂模式进行详细的说明:

    二、简单工厂模式:

            简单工厂模式的核心是定义一个创建对象的接口,将对象的创建和本身的业务逻辑分离,降低系统的耦合度,使得两个修改起来相对容易些,当以后实现改变时,只需要修改工厂类即可。

    如果不使用工厂,用户将自己创建宝马车,具体UML图和代码如下:

    public class BMW320 {
    	public BMW320(){
    		System.out.println("制造-->BMW320");
    	}
    }
     
    public class BMW523 {
    	public BMW523(){
    		System.out.println("制造-->BMW523");
    	}
    }
     
    public class Customer {
    	public static void main(String[] args) {
    		BMW320 bmw320 = new BMW320();
    		BMW523 bmw523 = new BMW523();
    	}
    }

            用户需要知道怎么创建一款车,这样子客户和车就紧密耦合在一起了,为了降低耦合,就出现了简单工厂模式,把创建宝马的操作细节都放到了工厂里,而客户直接使用工厂的创建方法,传入想要的宝马车型号就行了,而不必去知道创建的细节。

    1、简单工厂模式的UML图:

    • 工厂类角色: 该模式的核心,用来创建产品,含有一定的商业逻辑和判断逻辑
    • 抽象产品角色:它一般是具体产品继承的父类或者实现的接口。   
    • 具体产品角色:工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

    2、代码实现:

    产品类:

    abstract class BMW {
    	public BMW(){}
    }
     
    public class BMW320 extends BMW {
    	public BMW320() {
    		System.out.println("制造-->BMW320");
    	}
    }
    public class BMW523 extends BMW{
    	public BMW523(){
    		System.out.println("制造-->BMW523");
    	}
    }
    

    工厂类:

    public class Factory {
    	public BMW createBMW(int type) {
    		switch (type) {
    		
    		case 320:
    			return new BMW320();
     
    		case 523:
    			return new BMW523();
     
    		default:
    			break;
    		}
    		return null;
    	}
    }

    用户类:

    public class Customer {
    	public static void main(String[] args) {
    		Factory factory = new Factory();
    		BMW bmw320 = factory.createBMW(320);
    		BMW bmw523 = factory.createBMW(523);
    	}
    }

    3、简单工厂模式的优缺点:

            简单工厂模式提供专门的工厂类用于创建对象,实现了对象创建和使用的职责分离,客户端不需知道所创建的具体产品类的类名以及创建过程,只需知道具体产品类所对应的参数即可,通过引入配置文件,可以在不修改任何客户端代码的情况下更换和增加新的具体产品类,在一定程度上提高了系统的灵活性。

            但缺点在于不符合“开闭原则”,每次添加新产品就需要修改工厂类。在产品类型较多时,有可能造成工厂逻辑过于复杂,不利于系统的扩展维护,并且工厂类集中了所有产品创建逻辑,一旦不能正常工作,整个系统都要受到影响。

            为了解决简单工厂模式的问题,出现了工厂方法模式。

    三、工厂方法模式:

            工厂方法模式将工厂抽象化,并定义一个创建对象的接口。每增加新产品,只需增加该产品以及对应的具体实现工厂类,由具体工厂类决定要实例化的产品是哪个,将对象的创建与实例化延迟到子类,这样工厂的设计就符合“开闭原则”了,扩展时不必去修改原来的代码。在使用时,用于只需知道产品对应的具体工厂,关注具体的创建过程,甚至不需要知道具体产品类的类名,当我们选择哪个具体工厂时,就已经决定了实际创建的产品是哪个了。

            但缺点在于,每增加一个产品都需要增加一个具体产品类和实现工厂类,使得系统中类的个数成倍增加,在一定程度上增加了系统的复杂度,同时也增加了系统具体类的依赖。

    1、工厂方法的 UML 结构图如下:

    • 抽象工厂 AbstractFactory: 工厂方法模式的核心,是具体工厂角色必须实现的接口或者必须继承的父类,在 Java 中它由抽象类或者接口来实现。 
    • 具体工厂 Factory:被应用程序调用以创建具体产品的对象,含有和具体业务逻辑有关的代码
    • 抽象产品 AbstractProduct:是具体产品继承的父类或实现的接口,在 Java 中一般有抽象类或者接口来实现。 
    • 具体产品 Product:具体工厂角色所创建的对象就是此角色的实例。

    2、代码实现:

    产品类:

    abstract class BMW {
    	public BMW(){}
    }
    public class BMW320 extends BMW {
    	public BMW320() {
    		System.out.println("制造-->BMW320");
    	}
    }
    public class BMW523 extends BMW{
    	public BMW523(){
    		System.out.println("制造-->BMW523");
    	}
    }
    

    工厂类:

    interface FactoryBMW {
    	BMW createBMW();
    }
     
    public class FactoryBMW320 implements FactoryBMW{
     
    	@Override
    	public BMW320 createBMW() {
    		return new BMW320();
    	}
     
    }
    public class FactoryBMW523 implements FactoryBMW {
    	@Override
    	public BMW523 createBMW() {
    		return new BMW523();
    	}
    }
    

    客户类:

    public class Customer {
    	public static void main(String[] args) {
    		FactoryBMW320 factoryBMW320 = new FactoryBMW320();
    		BMW320 bmw320 = factoryBMW320.createBMW();
     
    		FactoryBMW523 factoryBMW523 = new FactoryBMW523();
    		BMW523 bmw523 = factoryBMW523.createBMW();
    	}
    }
    

    四、抽象工厂模式:

            在工厂方法模式中,我们使用一个工厂创建一个产品,一个具体工厂对应一个具体产品,但有时候我们需要一个工厂能够提供多个产品对象,而不是单一的对象,这个时候我们就需要使用抽象工厂模式。

            在介绍抽象工厂模式前,我们先厘清两个概念:

    • 产品等级结构:产品等级结构指的是产品的继承结构,例如一个空调抽象类,它有海尔空调、格力空调、美的空调等一系列的子类,那么这个空调抽象类和他的子类就构成了一个产品等级结构。
    • 产品族:产品族是指由同一个工厂生产的,位于不同产品等级结构中的一组产品。比如,海尔工厂生产海尔空调、海尔冰箱,那么海尔空调则位于空调产品族中。

    产品等级结构和产品族结构示意图如下:

    1、什么是抽象工厂模式:

            抽象工厂模式主要用于创建相关对象的家族。当一个产品族中需要被设计在一起工作时,通过抽象工厂模式,能够保证客户端始终只使用同一个产品族中的对象;并且通过隔离具体类的生成,使得客户端不需要明确指定具体生成类;所有的具体工厂都实现了抽象工厂中定义的公共接口,因此只需要改变具体工厂的实例,就可以在某种程度上改变整个软件系统的行为。

            但该模式的缺点在于添加新的行为时比较麻烦,如果需要添加一个新产品族对象时,需要更改接口及其下所有子类,这必然会带来很大的麻烦。

    2、UML结构图:

    • 抽象工厂 AbstractFactory:定义了一个接口,这个接口包含了一组方法用来生产产品,所有的具体工厂都必须实现此接口。
    • 具体工厂 ConcreteFactory:用于生产不同产品族,要创建一个产品,用户只需使用其中一个工厂进行获取,完全不需要实例化任何产品对象。
    • 抽象产品 AbstractProduct:这是一个产品家族,每一个具体工厂都能够生产一整组产品。
    • 具体产品 Product

    3、代码实现:

            通过抽象工厂模式,我们可以实现以下的效果:比如宝马320系列使用空调型号A和发动机型号A,而宝马230系列使用空调型号B和发动机型号B,在为320系列生产相关配件时,就无需制定配件的型号,它会自动根据车型生产对应的配件型号A。

            也就是说,当每个抽象产品都有多于一个的具体子类的时候(空调有型号A和B两种,发动机也有型号A和B两种),工厂角色怎么知道实例化哪一个子类呢?抽象工厂模式提供两个具体工厂角色(宝马320系列工厂和宝马230系列工厂),分别对应于这两个具体产品角色,每一个具体工厂角色只负责某一个产品角色的实例化,每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

    产品类:

    //发动机以及型号  
    public interface Engine {}  
    
    public class EngineA implements Engine{  
        public EngineA(){  
            System.out.println("制造-->EngineA");  
        }  
    }  
    public class EngineB implements Engine{  
        public EngineB(){  
            System.out.println("制造-->EngineB");  
        }  
    }  
     
    
    //空调以及型号  
    public interface Aircondition {} 
     
    public class AirconditionA implements Aircondition{  
        public AirconditionA(){  
            System.out.println("制造-->AirconditionA");  
        }  
    }  
    public class AirconditionB implements Aircondition{  
        public AirconditionB(){  
            System.out.println("制造-->AirconditionB");  
        }  
    } 
    

    创建工厂类:

    //创建工厂的接口  
    public interface AbstractFactory {  
        //制造发动机
        public Engine createEngine();
        //制造空调 
        public Aircondition createAircondition(); 
    }  
     
    //为宝马320系列生产配件  
    public class FactoryBMW320 implements AbstractFactory{     
        @Override  
        public Engine createEngine() {    
            return new EngineA();  
        }  
        @Override  
        public Aircondition createAircondition() {  
            return new AirconditionA();  
        }  
    }  
    //宝马523系列
    public class FactoryBMW523 implements AbstractFactory {  
         @Override  
        public Engine createEngine() {    
            return new EngineB();  
        }  
        @Override  
        public Aircondition createAircondition() {  
            return new AirconditionB();  
        }  
    } 
    

    客户:

    public class Customer {  
        public static void main(String[] args){  
            //生产宝马320系列配件
            FactoryBMW320 factoryBMW320 = new FactoryBMW320();  
            factoryBMW320.createEngine();
            factoryBMW320.createAircondition();
              
            //生产宝马523系列配件  
            FactoryBMW523 factoryBMW523 = new FactoryBMW523();  
            factoryBMW523.createEngine();
            factoryBMW523.createAircondition();
        }  
    }
    

    工厂模式小结:

    1、工厂方法模式与抽象工厂模式的区别在于:

    (1)工厂方法只有一个抽象产品类和一个抽象工厂类,但可以派生出多个具体产品类和具体工厂类,每个具体工厂类只能创建一个具体产品类的实例。

    (2)抽象工厂模式拥有多个抽象产品类(产品族)和一个抽象工厂类,每个抽象产品类可以派生出多个具体产品类;抽象工厂类也可以派生出多个具体工厂类,同时每个具体工厂类可以创建多个具体产品类的实例


    设计模式系列文章:

    Java设计模式之创建型:工厂模式详解(简单工厂+工厂方法+抽象工厂)

    Java设计模式之创建型:建造者模式

    Java设计模式之创建型:单例模式

    Java设计模式之创建型:原型模式

    Java设计模式之结构型:适配器模式

    Java设计模式之结构型:装饰器模式

    Java设计模式之结构型:代理模式

    Java设计模式之结构型:桥接模式

    Java设计模式之结构型:外观模式

    Java设计模式之结构型:组合模式

    Java设计模式之结构型:享元模式

    Java设计模式之行为型:策略模式

    Java设计模式之行为型:模板方法模式

    Java设计模式之行为型:责任链模式

    Java设计模式之行为型:观察者模式

    Java设计模式之行为型:访问者模式

    Java设计模式之行为型:中介者模式

    Java设计模式之行为型:命令模式

    Java设计模式之行为型:状态模式

    Java设计模式之行为型:备忘录模式

    Java设计模式之行为型:迭代器模式

    Java设计模式之行为型:解释器模式


    参考文章:

    设计模式读书笔记----简单工厂模式_chenssy 的技术博客-CSDN博客

    设计模式读书笔记----工厂方法模式_chenssy 的技术博客-CSDN博客

    设计模式读书笔记----抽象工厂模式_chenssy 的技术博客-CSDN博客

    JAVA设计模式之抽象工厂模式_一个本科小生的奋斗史-CSDN博客_java抽象工厂模式

    展开全文
  • 创建bean对象工厂 bean在计算机英语中,有可重用组件的含义 可重用:可反复使用。组件:组成部分,比如service可以被servlet反复使用,dao被service使用。service可以看成是可重用的组成部分。 javabean>=实体类...
  • 面向对象的语言大都有一个类的概念,通过类可以创建多个具有相同方法和属性的对象。虽然从技术上讲,javascript是一门面向对象的语言,但是javascript没有类的概念,一切都是对象。任意一个对象都是某种引用类型的...
  • 工厂方式工厂方式是指创建一个返回特定对象类型的工厂函数,示例代码如下: 代码如下:function createCar(sColor,iDoors,iMpg){ var oTempCar=new Object; oTempCar.color=sColor; oTempCar.doors=iDoors; ...
  • 面向对象的语言大都有一个类的概念,通过类可以创建多个具有相同方法和属性的对象。虽然从技术上讲,javascript是一门面向对象的语言,但是javascript没有类的概念,一切都是对象。任意一个对象都是某种引用类型的...
  • 面向对象的语言大都有一个类的概念,通过类可以创建多个具有相同方法和属性的对象。虽然从技术上讲,javascript是一门面向对象的语言,但是javascript没有类的概念,一切都是对象。任意一个对象都是某种引用类型的...
  • 工厂模式概念实现简单工厂工厂方法工厂方法优点抽象工厂工厂方法和抽象工厂的比较 概念 在面向对象中,工厂表示一个负责创建其他类型对象的类。 工厂具有: 松耦合 客户端无需了解创建对象的类,但是照样可以使用它...
  • (不过,ES6引入了Class这个概念,作为对象的模板。通过class关键字,可以定义类。ES6入门:http://es6.ruanyifeng.com/)。 但是在项目开发中,经常用到JS面向对象开发,这就需要我们去用JS创建类,从而去实例化...
  • 软考(软件设计师)考点总结 -- 面向对象设计基础

    千次阅读 多人点赞 2021-05-21 17:31:21
    软考软件设计师考点总结 -- 面向对象基础:面向对象基本概念、面向对象的特性、分析、设计原则、设计模式:创建型模式、结构型模式、行为型模式、UML基本概念、UML模型。
  • 【Java设计模式】抽象工厂

    千次阅读 多人点赞 2019-07-07 09:36:19
    抽象工厂能够将一组具有同一主题和单独的工厂封装起来,在正常使用中,客户端程序创建抽象工厂的具体实现,然后使用抽象工厂作为接口来创建这一主题的具体实现,我们不需要关心内部方法中获得对象的具体类型, ...
  • 相关概念:定义:工厂方法模式(FACTORY METHOD)是一种常用的对象创建型设计模式,此模式的核心精神是封装类中不变的部分,提取其中个性化善变的部分为独立类,通过依赖注入以达到解耦、复用和方便后期维护拓展的目的...
  • 两大类数据模型客观对象的抽象过程---两步抽象3.数据模型的组成要素(1)数据结构(2)数据操作(3)数据的完整性约束条件4.概念模型(1)用途与基本要求(2) 信息世界中的基本概念(3)两个实体型之间的联系① 一对一联系(1:1...
  • 这个应该是软件开发者喜欢的模型,使用面向对象分析(OOA)和面向对象设计(OOD)过程中所建立模型,包括类图、对象图、状态图以及与之相关的活动图、顺序图、组件图等,可以利用UML建模工具,如Rose、Infosphere ...
  • 我女朋友愿意和我一起骑着单车,享受着属于我们的时光,每次她那纯真的笑容,让我心情特别的舒畅。 冬天的时候,骑在单车上特别的冷,这时候...在代码中什么是工厂:通过定义一个单独的创建对象的类来创建其它的...
  • java 三种工厂模式(简单工厂+工厂方法+抽象工厂)

    万次阅读 多人点赞 2019-06-04 10:51:15
    一、简单工厂模式 概述   简单工厂模式:定义一个工厂类,它可以根据参数的不同返回不同类的 实例,被创建的实例通常都具有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态(static)方法,因此简单工厂...
  • 在今天我刚阅读了《kafka权威指南》的第一章,关于介绍kafka这个消息发布与订阅系统的概念。在之前的一份实习中,我曾经接触到了kafka,但是我一知半解,也没有深入的了解为什么会有kafka的存在。恰巧前几天我在市...
  • 1 简单工厂(Simple Factory) 1.1 问题引出 假如有一个披萨店,Pizza的种类有很多,如CheesePizza、VeggiePizza、PepperPizza等。披萨店根据收到的订单制作Pizza,披萨的制作流程有材料的准备材料、烤、切、包装几步...
  • 先看一下golang的Tiobe指数趋势: 可以看到在2017年7月,...按照国际惯例,讲完单例模式,接下来就该轮到工厂模式。还是那句话,每个人对设计模式的理解都有所不同,欢迎各位探讨。 何为工厂模式 WIKI: In clas

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 126,190
精华内容 50,476
关键字:

对象工厂的概念