设计模式基于面向对象技术，是人们在长期的开发实践中良好经验的结晶，提供了一个简单..

免费智能真题库 > 历年试卷 > 系统架构设计师 > 2016年下半年系统架构设计师上午试卷综合知识

第54题

知识点：设计模式目录的内容抽象复用功能性继承面向对象技术软件设计设计模式

关键词：继承接口开发面向对象软件设计设计模式对象章/节：设计模式

设计模式基于面向对象技术，是人们在长期的开发实践中良好经验的结晶，提供了一个简单、统一的描述方法，使得人们可以复用这些软件设计办法、过程管理经验。按照设计模式的目的进行划分，现有的设计模式可以分为创建型、（54）和行为型三种类型。其中（55）属于创建型模式，（56）属于行为型模式。（57）模式可以将一个复杂的组件分成功能性抽象和内部实现两个独立的但又相关的继承层次结构，从而可以实现接口与实现分离。

A. 合成型

B. 组合型

C. 结构型

D. 聚合型

相关试题：设计模式的分类

更多>

第32题 2014年下半年

31%

一组对象以定义良好但是复杂的方式进行通信，产生的相互依赖关系结构混乱且难以理解。采用（32）模式，用一个特定对象来封装一系..

第55题 2019年下半年

39%

设计模式按照目的可以划分为三类，其中， (54) 模式是对对象实例化过程的抽象。例如 &..

第61题 2009年下半年

71%

某软件公司承接了为某工作流语言开发解释器的工作。该工作流语言由多种活动节点构成，具有类XML的语法结构。用户要求解释器工作时..


知识点讲解
· 设计模式目录的内容 · 抽象 · 复用 · 功能性 · 继承 · 面向对象技术 · 软件设计 · 设计模式

设计模式目录的内容

Erich Gamma在他的博士论文中总结了一系列的设计模式，做出了开创性的工作。他用一种类似分类目录的形式将设计模式记载下来。我们称这些设计模式为设计模式目录。根据模式的目标（所做的事情），可以将它们分成创建性模式（creational）、结构性模式（structural）和行为性模式（behavioral）。创建性模式处理的是对象的创建过程，结构性模式处理的是对象／类的组合，行为性模式处理类和对象间的交互方式和任务分布。根据它们主要的应用对象，又可以分为主要应用于类的和主要应用于对象的。

下表是Erich Gamma等总结的23种设计模式，这些设计模式通常称为GoF（Gang of Four，四人组）模式。因为这些模式是在“Design Patterns:Elements of Reusable Object-Oriented Software”中正式提出的，而该书的作者是Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides，这几位作者常被称为“四人组”。

设计模式目录的分类

其中带*模式是关于类的，其他模式是关于对象的。

抽象

抽象是一种设计技术，重点说明一个实体的本质方面，而忽略或者掩盖不很重要或非本质的方面。抽象是一种重要的工具，用来将复杂的现象简化到可以分析、实验或者可以理解的程度。软件工程中从软件定义到软件开发要经历多个阶段，在这个过程中每前进一步都可看作是对软件解法的抽象层次的一次细化。抽象的最低层就是实现该软件的源程序代码。在进行模块化设计时也可以有多个抽象层次，最高抽象层次的模块用概括的方式叙述问题的解法，较低抽象层次的模块是对较高抽象层次模块对问题解法描述的细化。

复用

软件复用是指将已有的软件及其有效成分用于构造新的软件或系统。构件技术是软件复用实现的关键。

功能性

功能性是指当软件在指定条件下使用时，软件产品满足明确和隐含要求功能的能力。

适合性

适合性是指软件产品为指定的任务和用户目标提供一组合适的功能的能力。

准确性

准确性是指软件产品具有所需精确度的正确或相符的结果及效果的能力。

互操作性

互操作性是指软件产品与一个或更多的规定系统进行交互的能力。

保密安全

保密安全是指软件产品保护信息和数据的能力，以使未授权的人员或系统不能阅读或修改这些信息和数据，但不拒绝授权人员或系统对它们的访问。

功能性依从性

功能性依从性是指软件产品依附于同功能性相关的标准、约定或法规以及类似规定的能力。

继承

继承可以在类型的级别上进行，也可以在表级别上进行，下面分别介绍。

类型继承

如希望在数据库中对那些是学生和教师的人分别存储一些额外的信息。

由于学生和教师是人，所以可以使用继承。在SQL-99中定义学生和教师类型如下：

Student和Teacher都继承了Person的属性，即name和address。Student和Teacher被称为Person的子类型，Person是Student的超类型，同时也是Teacher的超类型。像属性一样，结构类型的方法也被它的子类型继承。不过，子类型可以通过在一个方法声明中使用overriding method（重载方法）取代原method（方法）的方式重新声明方法，以重定义该方法的作用。

现在假定要存储关于助教的信息，这些助教既是学生又是教师，甚至可能是在不同的系里。可以利用多重继承（multiple inheritance）的方法来做。SQL-99标准不支持多重继承，然而SQL-99标准是提供多重继承的，尽管SQL-99最终版中忽略了它，但SQL标准的未来版本可能会引入它。基于SQL-99标准的草案来讨论问题。

TeacherAssistant将继承Student和Teacher的所有属性。由于name和address属性实际上是从同一个来源即Person继承来的，因此同时从Student和Teacher中都继承这两个属性不会引起冲突。但是，一个助教既可能是某个系的学生同时又是另一个系的教师，所以department属性在Student和Teacher中分别都有定义。为了避免两次出现的department之间的冲突，我们可以使用as子句将它们重新命名，如下面的TeachingAssistant类型定义所示：

注意SQL-99只支持单继承，即一个类型只能继承一种类型，使用的语法如例8.35。TeachingAssistant例子中的多重继承在SQL-99中是不支持的。SQL-99标准还需要在类型定义的尾部有一个特别的字段，取值为final或not final。其中，关键字final表示不能从给定类型创建子类型，not final表示可以创建子类型。

SQL中的一个结构类型的值必须恰好只有一个“最明确类型（most-specific type）”，即每一个值被创建时必须关联到一个确定的类型，称为它的最明确类型。依靠继承，它也与它的最明确类型的每个超类型相关联。举例来说，假定一个实体具有类型Person，同时又具有类型Student，那么这个实体的最明确类型为Student，因为Student是Person的子类型。然而一个实体不能同时既具有类型Student又具有类型Teacher，除非这个实体具有一个如TeacherAssistant那样既是Student子类型又是Teacher的子类型的类型。

表继承

SQL-99中的子表（subtable）对应的是E-R概念中的特殊化／一般化。子表的类型必须是父表类型的子类型，因此，父表中的每一个属性均出现在子表中。

定义子表students和teachers如下：

当我们声明students和teachers作为people的子表时，每一个students或teachers中出现的元组也隐式存在于people中。如果一个查询用到people表，它将查找的不仅仅是直接插入到这个表中的元组，而且还包含插入到它的子表（也就是students和teachers）中的元组。但是，只有出现在people中的属性才可以被访问。

多重继承也可在表进行。例如，创建一个类型为TeachingAssistant的表：

作为声明的结果，每一个在teaching-assistants中出现的元组也隐式地在表teachers和students中出现，从而也出现在people表中。SQL-99允许在查询中使用“only people”代替people来查询只在people中而不在它的子表中的元组。

对子表的一致性要求。如果一个子表和一个父表中的元组对于所有的继承属性具有同样的值，则称子表中的元组符合（correspond to）父表中的元组。因此，相符合的元组表示同一个实体。子表的一致性需求为：

.父表的每个元组至多可以与它的每个直接子表的一个元组符合。

.SQL-99有一个附加的约束，所有相符合的元组必须由一个元组派生（插入到一个表中）。

例如，若没有第一个条件，我们就可能在students（或teachers）中有两个元组与同一个人符合。第二个条件排除了people中的一个元组分别符合students和teachers中的一个元组的情况，除非所有这些元组都隐式出现。这是由于一个元组会被插入到一个既是teacher的子表又是students的子表的teaching-assistants表中。

由于SQL-99不支持多重继承，所以第二个条件实际上阻止一个人既是老师又是学生。即使支持多重继承，这个问题在没有子表teaching-assistants时也会出现。显然，建立一个即使没有teaching-assistants子表也可以让一个人既是老师又是学生的环境是很有用的。因此，去掉第二个一致性约束是有用的。

子表可以采用无须复制所有的继承字段的有效方式进行存储，通常有如下两种方式：

.每一个表只存储主码（可能是从父表中继承来的）和局部定义的属性。继承属性（主码之外的）不需要存储，因为它可以基于主码与父表连接得到。

.每一个表存储所有继承的和局部定义的属性。当插入一个元组时，它仅仅存储在它被插入的那个表中，在它的每个父表中推断它的出现。因为不需要连接，所以可快速访问元组的所有属性。不过，一旦没有第二个一致性约束（即一个实体可能出现在两个子表中而不在它们的公共子表中出现），这种表达将导致信息重复的问题。

面向对象技术

在介绍面向对象软件测试之前，有必要先对面向对象技术的基本概念做一下简单介绍。

对象和类

面向对象其实是现实世界模型的自然延伸。现实世界中任何实体都可以看作是对象。对象之间通过消息相互作用。另外，现实世界中任何实体都可归属于某类事物，任何对象都是某一类事物的实例。如果说传统的过程式编程语言是以过程为中心，以算法为驱动的话，那么面向对象的编程语言则是以对象为中心，以消息为驱动的。用公式表示，过程式编程语言为：程序=算法+数据；面向对象编程语言为：程序=对象+消息。

在面向对象的程序设计中，类是其设计的核心，它实际是一种新的数据类型，也是实现抽象类型的工具，类是通过抽象数据类型的方法来实现的一种数据类型。类是对某一类对象的抽象；而对象是某一种类的实例，因此，类和对象是密切相关的。没有脱离对象的类，也没有不依赖于类的对象。

封装、继承和多态性

封装，把数据和操作结合成一体，使程序结构更加紧凑，同时避免了数据紊乱带来的调试与维护的困难；继承，增加了软件的可扩充性，并为代码重用提供了强有力的手段；多态性，使程序员在设计程序时可以对问题进行更好的抽象，易设计出重用性和维护性俱佳的程序。

封装是将数据和操作数据的函数衔接在一起，构成的一个具有类类型的对象的描述。封装要求一个对象应具备明确的功能，并且有一个或几个接口以便和其他对象相互作用。同时，对象的内部实现（代码和数据）是受保护的，外界不能访问它们，只有对象中的代码才可以访问该对象的内部数据。对象的内部数据结构的不可访问性称为数据隐藏。封装简化了程序员对对象的使用，只需要知道输入什么和输出什么，而对类内部进行什么操作不必追究。

例如，类Test（以C++为例）：

输出结果是16，对于main（）里的操作，无法更改类Test中的Value值，这样保护了数据Value，实现了数据的隐藏。函数SetValue（）和数据Value结合在一起操作，这就实现了封装。

继承即可以从一个类派生另一个类。派生类（也称为子类）继承了其父类和祖先类的数据成员和成员函数。派生类可增加新的属性和新的操作，另外，派生类在继承的成员函数不合适时也可以放弃不用。

例如，水果是基类，它具有好吃、营养等水果的基本特征；香蕉和苹果是水果的派生类，它们在继承水果类的一些特征的基础上，增加了各自的特征，如特殊的味道、形状等；红富士苹果和青苹果是苹果类的派生类，它们又增加了各自的新特征。如此继承设计，可以大大减少工作量。

例如（C++程序），先设计水果类Friut。

苹果类Apple需要与水果类Friut同样的成员函数void Eat和void Taste，另外增加了新的函数void Color和void Shape。在设计时，我们不需要重写void Eat和void Taste，只需要继承水果类即可，苹果类的实际代码如下。

多态性就是多种表现形式，具体来说，可以用“一个对外接口，多个内在实现方法”表示。多态性的实现，一般通过在派生类中重定义基类的虚函数来实现。

如下例（C++程序），如果A是基类，B和C是A的派生类，基类中多态函数Test的参数是A的指针。那么Test函数可以引用A、B、C的对象如下。

正是面向对象软件所独有的这些多态、继承、封装等新特点，使OO程序设计比传统语言程序设计产生错误的可能性更大，使得传统软件测试中的重点不再显得那么突出，也使原来测试经验和实践证明的次要方面成为了主要问题。例如，在传统的面向过程程序中，对于函数y=Func（x）；你只需要考虑一个函数“Func（）”的行为特点，而在面向对象程序中，你不得不同时考虑基类函数“Base::Func（）”的行为和继承类函数“Derived::Func（）”的行为。

面向对象程序的结构不再是传统的功能模块结构，作为一个整体，原有集成测试所要求的，逐步将开发的模块搭建在一起进行测试的方法已不可能。而且，面向对象软件抛弃了传统的开发模式，对每个开发阶段都有不同于以往的要求和结果，已经不可能用功能细化的观点来检测面向对象分析和设计的结果。因此，传统的测试模型对面向对象软件已经不再适用。针对面向对象软件的开发特点，一种新的面向对象测试模型应需而生。

软件设计

软件设计的任务

在给定系统的需求规格说明书后，需要对软件的结构进行设计，并对设计的过程进行管理。在嵌入式系统的软件设计过程中，需要完成以下一些任务。

准备工作计划

在软件设计之前，首先要制订详细的工作计划，其内容包括：

.过程管理方案：包括软件开发的进度管理、软件规模和所需人年的估算、开发人员的技能培训等；

.开发环境的准备方案：包括开发工具的准备、开发设备的准备、测试装备的准备、分布式开发环境下的开发准则等；

.软硬件联机调试的方案：联调的起始时间、地点、人员和具体的准备工作；

.质量保证方案：包括质量目标计划、质量控制计划等；

.配置控制方案：包括配置控制文档的编写、配置控制规则的制订等。

确定软件的结构

设计软件的各个组成部分，包括：

.任务结构的设计：使用操作系统提供的函数，设计出一个最佳的任务结构；

.线程的设计；

.公共数据结构的设计：在确保系统一致性的基础上，设计出所需的公共数据；

.操作系统资源的定义；

.类的设计；

.模块结构设计：在设计时要充分考虑模块的划分、标准化、可重用和灵活性等；

.内存的分配与布局。

设计评审

对于软件设计的结果，进行一次设计评审，并在必要时对设计进行修正。具体内容包括：

.确认每件工作的执行方法是否恰当，其内容是否完善；

.确认该设计完成了系统需求规格说明书所要求的功能和服务；

.评估任务结构设计、评估类的设计、评估模块结构设计；

.对软件设计的结果进行总结，编写出相应的文档。

维护工作计划

执行软件设计工作控制，在每日、每周和每月的时间粒度上对进度进行控制，确保软件设计能够如期完成。

与硬件部门密切合作、相互协调

根据工作计划中的安排，定期与硬件部门召开会议，协调各自的进展。如果软件规格说明书发生了变化，立即进行调整，重新进行软件设计。

控制工作的结果，把工作记录存档

掌握当前的工作进展情况，尽早地发现和分析问题，并采取相应的措施。对各种事件进行跟踪记录，包括：

.执行过程控制，跟踪进展情况并定期记录、存档。

.执行质量控制，保留质量记录。

.记录产品的配置、版本变化、bug的发现和处理等信息。

软件架构设计

软件架构也称为软件体系结构，需要考虑如何对系统进行分解，对分解后的组件及其之间的关系进行设计，满足系统的功能和非功能需求。软件架构形成过程如下图所示。

架构的形成过程概要

软件架构设计需要从用户业务需求、未来应用环境、需求分析、硬件基础、接口输入、数据处理、运算或控制规律、用户使用等方面进行综合、权衡和分析基础上产生。面向某种问题的架构一旦确定就很难改变，随后的架构设计需要通过一系列的迭代开发完善，使得软件架构日趋成熟、稳定。

软件架构的重要作用也在于控制一个软件系统的使用、成本和风险。好的架构要求是和谐的软件架构，包括与上一级系统架构相互和谐、与系统中同一级的其他组件架构互相和谐，确保系统满足性能、可靠性、安全性、信息安全性和互操作性等方面的关键要求，也具有可扩展、可移植性，从而为一个软件带来长久的生命力。

在大量开发实践中，有很多广泛使用并被普遍接受的软件架构设计原则，这些原则独立于具体的软件开发方法，主要包括抽象、信息隐藏、强内聚和松耦合、关注点分离等。

（1）抽象：这是软件架构的核心原则，也是人们认识复杂客观世界的基本方法。抽象的实质是提取主要特征和属性，从具体的事务中通过封装来忽略细节，并且运用这些特征和属性，描述一个具有普遍意义的客观世界。软件架构设计中需要对流程、数据、行为等进行抽象。复杂系统含有多层抽象，从而有多个不同层次架构。

（2）信息隐藏：包括局部化设计和封装设计。局部化设计就是将一个处理所涉及到的信息和操作尽可能地限制在局部的一个组件中，减少与其他组件的接口。而封装设计是将组件的外部访问形式尽可能简单、统一。

（3）强内聚和松耦合：强内聚是指软件组件内的特性，即组件内所有处理都高度相关，所有处理组合在一起才能组成一个相对完整的功能。而松耦合是指软件组件之间的特性，软件组件之间应尽量做到没有或极少的直接关系，使其保持相对独立，这样使得未来的修改、复用简单，修改之后带来的影响最小。

（4）关注点分离：所谓关注点是软件系统中可能会遇到的多变的部分。如为适应不同运行接口条件，需要进行适应性的参数调整和驱动配置。关注点分离设计是将这部分组件设计成为相对独立的部分，使未来的系统容易配置和修改。而核心的部分可以保持一个相对独立的稳定状态。如果功能分配使得单独的关注点组件足够简单，那么就更容易理解和实现。但“展示某些关注点得到满足时，可能会影响到其他方面的关注点，但架构师必须能够说明所有关注点都已得到满足”。

以上的原则中，删除需求细节或对细节进行抽象是最重要的工作，为用户的需求创建抽象模型，通过抽象将特殊问题映射为更普遍的问题类别，并识别各种模式。

软件架构设计使用纵向分解和横向分解两种方式。纵向分解就是分层，横向分解就是将每一个层面分成相对独立的部分。经过分解之后，可以将一个完整的问题分解成多个模块来解决。模块是其中可分解、可组装，功能独立、功能高度内聚、之间低耦合的一个组件。

类似于建筑架构，软件架构也决定了软件产品的好用、易用、可靠、信息安全、可扩展、可重用等特性，好的软件架构也给人完整、明确、清晰等赏心悦目的感觉，具有较长的生命力。

架构设计是围绕业务需求带来的问题空间到系统解决空间第一个顶层设计方案。按照抽象原则，在这个阶段进行的架构设计关注软件设计环节抽象出来的重要元素，而不是所有的设计元素。在架构设计时将软件这些要素看作是黑盒，架构设计需要满足黑盒的外部功能和非功能需求的目标。一个软件的架构设计首先为软件产品的后续开发过程提供基础，在此基础上可将一个大规模的软件分解为若干子问题和公共子问题。而一般意义的软件设计是软件的底层设计，开发人员需要关注各子问题或要素的进一步分解和实现，是根据架构设计所定义的每个要素的功能、接口，进一步实现要素组件内部的配置、处理和结构。在遵守组件外部属性前提下，考虑实现组件内部的细节及其实现方法。对于其中的公共子问题，形成公共类和工具类，从而可以达到重用的目的。

一般的软件构架是根据需求自上而下方式来设计，即首先掌握和研究利益相关方的关键需求，基本思路是首先进行系统级的软件架构设计，需要将软件组件与其外部环境属性绑定在一起，关注软件系统与外部环境的交联设计；其次将一个大的系统划分成各组成部分，这些部分可以按照架构设计的不同方法，分为层次或成为模块；之后再开始研究所涉及到的要素，再实现这些要素以及定义这些要素之间的关系。

在实际工作中，软件构架也可采用自底向上的方法，前提是已经建立了一个成熟稳定的软件架构，也可以称之为“模式”。模式是组织一级设计某一类具体问题的顶层思路，是为了解决共有问题解的方案模板，但并不是一个问题的设计或设计算法。

模式常常整合在一起使用，提供解决更大、更复杂问题的解决方案，而组成一个解决问题的通用框架。框架往往提供统一平台和开发工具，而且已经高效地利用了已经经过验证的模式、技术和组件。在新软件系统的设计中指定沿用或重用这种架构框架，这时其他重要元素可以在这个架构基础上针对新的需求进行扩展，有时是针对性地进行参数化设计。所以在架构设计中可以借用模式的概念进行设计，采用成熟的先进的设计框架和工具提高开发的效率，保证设计正确性。

下图所示是针对架构设计中非功能需求的多维度分析，从中可知任何一个因素的变化都会带来对其他因素的影响。实际上软件架构设计属于软件设计过程的一部分，但超越了系统内部的算法和数据结构的详细设计。

架构的多维度分析

在架构设计阶段，需要定义边界条件、描述系统组织结构、对系统的定量属性进行约束、帮助对模型进行描述并基本构造早期的原型、更准确地描述费用和时间的评估。

软件设计方法

在将系统分解为各个组件的过程中，需要采取不同的策略，而每个策略则关注不同的设计概念。根据分解过程中所采用的不同策略，设计方法有基于功能分解的设计方法、基于信息隐藏的设计方法和基于模型驱动开发的设计方法等分类。

（1）基于功能分解的设计方法。实时结构化分析与设计采用了功能分解，系统被分解为多个函数，并且以数据流或控制流的形式定义函数之间的接口；基于并发任务结构化的设计（Design Approach for Real-Time Systems，DARTS）提供了任务结构化标准，辅助人员确定系统中的并发任务，并指导定义任务接口。

（2）基于信息隐藏的设计方法。面向对象（Object Oriented，OO）设计方法将数据和数据上操作封装在对象实体中，对象外界不能够直接对对象内部进行访问和操作，只能通过消息间接访问对象，符合人类思维方式，提高软件的扩展性、维护性和重用性。

（3）基于模型驱动开发的设计方法。通过借助有效的（Model Driven Development，MDD）工具，构建和维护复杂系统的设计模型，直接产生高质量的代码，将开发的重心从编码转移到设计。当前使用较为广泛的MDD工具有IBM公司的Rhapsody。

设计模式

“每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心。这样，你就能一次又一次地使用该方案而不必做重复劳动”。设计模式的核心在于提供了相关问题的解决方案。

设计模式一般有如下4个要素。

（1）模式名称（pattern name）。模式名称应具有实际的含义，能反映模式的适用性和意图。

（2）问题（problem）。描述了应该在何时使用模式，解释了设计问题和问题存在的前因后果。可能描述了特定的设计问题，如怎样用对象表示算法等；也可能描述了导致不灵活设计的类或对象结构。有时候，问题部分会包括使用模式必须满足的一系列先决条件。

（3）解决方案（solution）。描述了设计的组成成分，它们之间的相互关系及各自的职责和协作方式。解决方案并不描述一个特定的具体的设计或实现，而是提供设计问题的抽象描述和怎样用一个具有一般意义的元素组合（类或对象组合）来解决这个问题。

（4）效果（consequences）。描述了模式应用的效果及使用模式应权衡的问题。因为复用是面向对象设计的要素之一，所以模式效果包括它对系统的灵活性、扩充性或可移植性的影响，显式地列出这些效果对理解和评价这些模式很有帮助。

设计模式确定了所包含的类和实例，它们的角色、协作方式以及职责分配。每一个设计模式都集中于一个特定的面向对象设计问题或设计要点，描述了什么时候使用它，在另一些设计约束条件下是否还能使用，以及使用的效果和如何取舍。按照设计模式的目的可以分为创建型、结构型和行为型三大类，如下表所示。

设计模式分类

创建型设计模式

创建型模式与对象的创建有关，抽象了实例化过程，它们帮助一个系统独立于如何创建、组合和表示它的那些对象。一个类创建型模式使用继承改变被实例化的类，而一个对象创建型模式将实例化委托给另一个对象。

创建型模式包括面向类和面向对象两种。Factory Method（工厂方法）定义一个用于创建对象的接口，让子类决定实例化哪一个类。Abstract Factory（抽象工厂）提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。Builder（生成器）将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。Factory Method使一个类的实例化延迟到其子类。Prototype（原型）用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。Singleton（单例）模式保证一个类仅有一个实例，并提供一个访问它的全局访问点。

下面以抽象工厂模式和单例模式为例进行说明。

Abstract Factory（抽象工厂）

（1）意图。提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

（2）结构。抽象工厂模式的结构如下图所示。

抽象工厂模式结构图

其中：

.AbstractFactory声明一个创建抽象产品对象的操作接口。

.ConcreteFactory实现创建具体产品对象的操作。

.AbstractProduct为一类产品对象声明一个接口。

.ConcreteProduct定义一个将被相应的具体工厂创建的产品对象，实现AbstractProduct接口。

.Client仅使用由AbstractFactory和AbstractProduct类声明的接口。

（3）适用性。Abstract Factory模式适用于：

.一个系统要独立于它的产品的创建、组合和表示时。

.一个系统要由多个产品系列中的一个来配置时。

.当要强调一系列相关的产品对象的设计以便进行联合使用时。

.当提供一个产品类库，只想显示它们的接口而不是实现时。

Singleton（单例）

（1）意图。保证一个类仅有一个实例，并提供一个访问它的全局访问点。

（2）结构。单例模式的结构如下图所示。

单例模式结构图

其中：Singleton指定一个Instance操作，允许客户访问它的唯一实例，Instance是一个类操作；可能负责创建它自己的唯一实例。

（3）适用性。Singleton模式适用于：

.当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。

.当这个唯一实例应该是通过子类化可扩展的，并且客户无须更改代码就能使用一个扩展的实例时。

结构型设计模式

结构型模式处理类或对象的组合，涉及如何组合类和对象以获得更大的结构。结构型类模式采用继承机制来组合接口或实现。一个简单的例子是采用多重继承方法将两个以上的类组合成一个类，结果这个类包含了所有父类的性质。这一模式尤其有助于多个独立开发的类库协同工作。其中一个例子是类形式的Adapter（适配器）模式。一般来说，适配器使得一个接口与其他接口兼容，从而给出了多个不同接口的统一抽象。为此，类Adapter对一个adaptee类进行私有继承。这样，适配器就可以用adaptee的接口表示它的接口。对象Adapter依赖于对象组合。

下面以适配器模式和代理模式为例进行说明。

Adapter（适配器）模式

（1）意图。将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

类适配器结构图

（2）结构。类适配器使用多重继承对一个接口与另一个接口进行匹配，其结构如上图所示。对象适配器依赖于对象组合，其结构如下图所示。

对象适配器结构图

其中：

.Target定义Client使用的与特定领域相关的接口。

.Client与符合Target接口的对象协同。

.Adaptee定义一个已经存在的接口，这个接口需要适配。

.Adapter对Adaptee的接口与Target接口进行适配。

（3）适用性。Adapter模式适用于：

.想使用一个已经存在的类，而它的接口不符合要求。

.想创建一个可以服用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。

.（仅适用于对象Adapter）想使用一个已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。

Proxy（代理）模式

（1）意图。为其他对象提供一种代理以控制对这个对象的访问。

（2）结构。代理模式的结构如下图所示。

代理模式结构图

其中：

.Proxy保存一个引用使得代理可以访问实体；提供一个与Subject的接口相同的接口，使代理可以用来代替实体；控制对实体的存取，并可能负责创建和删除它；其他功能依赖于代理的类型：Remote Proxy负责对请求及其参数进行编码，并向不同地址空间中的实体发送已编码的请求；Virtual Proxy可以缓存实体的附加信息，以便延迟对它的访问；Protection Proxy检查调用者是否具有实现一个请求所必需的访问权限。

.Subject定义RealSubject和Proxy的共用接口，这样就在任何使用RealSubject的地方都可以使用Proxy。

.RealSubject定义Proxy所代表的实体。

（3）适用性。Proxy模式适用于在需要比较通用和复杂的对象指针代替简单的指针的时候，常见情况有：

.远程代理（Remote Proxy）为一个对象在不同地址空间提供局部代表。

.虚代理（Virtual Proxy）根据需要创建开销很大的对象。

.保护代理（Protection Proxy）控制对原始对象的访问，用于对象应该有不同的访问权限的时候。

.智能引用（Smart Reference）取代了简单的指针，它在访问对象时执行一些附加操作。典型用途包括：对指向实际对象的引用计数，这样当该对象没有引用时，可以被自动释放；当第一次引用一个持久对象时，将它装入内存；在访问一个实际对象前，检查是否已经锁定了它，以确保其他对象不能改变它。

结构型对象模式不是对接口和实现进行组合，而是描述了如何对一些对象进行组合，从而实现新功能的一些方法。因为可以在运行时刻改变对象组合关系，所以对象组合方式具有更大的灵活性，而这种机制用静态类组合是不可能实现的。

Composite（组合）模式将对象组合成树型结构以表示“部分—整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。它描述了如何构造一个类层次式结构，这一结构由两种类型的对象所对应的类构成。其中的组合对象使得用户可以组合基元对象以及其他的组合对象，从而形成任意复杂的结构。proxy（代理）模式为其他对象提供一种代理以控制对这个对象的访问，其中，proxy对象作为其他对象的一个方便的替代或占位符。它的使用可以有多种形式，例如可以在局部空间中代表一个远程地址空间中的对象，也可以表示一个要求被加载的较大的对象，还可以用来保护对敏感对象的访问。proxy模式还提供了对对象的一些特有性质的一定程度上的间接访问，从而可以限制、增强或修改这些性质。Flyweight（享元）模式运用共享技术有效地支持大量细粒度的对象，为了共享对象定义了一个结构。至少有两个原因要求对象共享：效率和一致性。Flyweight的对象共享机制主要强调对象的空间效率。使用很多对象的应用必须考虑每一个对象的开销。使用对象共享而不是进行对象复制，可以节省大量的空间资源。但是，仅当这些对象没有定义与上下文相关的状态时，它们才可以被共享。Flyweight的对象没有这样的状态。任何执行任务时需要的其他一些信息仅当需要时才传递过去。由于不存在与上下文相关的状态，因此Flyweight对象可以被自由地共享。

Facade（外观）模式为子系统中的一组接口提供一个一致的界面，定义了一个高层接口，这个接口使得这一子系统更加容易使用。该模式描述了如何用单个对象表示整个子系统。模式中的facade用来表示一组对象，facade的职责是将消息转发给它所表示的对象。Bridge（桥接）模式将对象的抽象和其实现分离，从而可以独立地改变它们。

Decorator（装饰）模式描述了如何动态地为对象添加一些额外的职责。该模式采用递归方式组合对象，从而允许添加任意多的对象职责。例如，一个包含用户界面组件的Decorator对象可以将边框或阴影这样的装饰添加到该组件中，或者它可以将窗口滚动和缩放这样的功能添加到组件中。可以将一个Decorator对象嵌套在另外一个对象中，就可以很简单地增加两个装饰，添加其他的装饰也是如此。因此，每个Decorator对象必须与其组件的接口兼容并且保证将消息传递给它。Decorator模式在转发一条信息之前或之后都可以完成它的工作（例如绘制组件的边框）。许多结构型模式在某种程度上具有相关性。

行为型设计模式

行为模式对类或对象怎样交互和怎样分配职责进行描述，涉及算法和对象间职责的分配。行为模式不仅描述对象或类的模式，还描述它们之间的通信模式。这些模式刻画了在运行时难以跟踪的复杂的控制流。它们将用户的注意力从控制流转移到对象间的联系方式上来。

行为类模式使用继承机制在类间分派行为。本章包括两个这样的模式，其中Template Method（模板方法）较为简单和常用。Template Method是一个算法的抽象定义，它逐步地定义该算法，每一步调用一个抽象操作或一个原语操作，子类定义抽象操作以具体实现该算法。另一种行为类模式是Interpreter（解释器）模式，它将一个文法表示为一个类层次，并实现一个解释器作为这些类的实例上的一个操作。

行为对象模式使用对象复合而不是继承。一些行为对象模式描述了一组对等的对象怎样相互协作以完成其中任一个对象都无法单独完成的任务。这里一个重要的问题是对等的对象。

如何互相了解对方。对等对象可以保持显式的对对方的引用，但那会增加它们的耦合度。在极端情况下，每一个对象都要了解所有其他的对象。Mediator（中介者）模式用一个中介对象来封装一系列的对象交互，在对等对象间引入一个mediator对象以避免这种情况的出现。mediator提供了松耦合所需的间接性。

Chain of Responsibility（责任链）使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系，将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。Chain of Responsibility模式提供更松的耦合，让用户通过一条候选对象链隐式地向一个对象发送请求。根据运行时刻情况任一候选者都可以响应相应的请求。候选者的数目是任意的，可以在运行时刻决定哪些候选者参与到链中。

Observer（观察者）模式定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。典型的Observer的例子是Smalltalk中的模型／视图／控制器，其中一旦模型的状态发生变化，模型的所有视图都会得到通知。

其他的行为对象模式常将行为封装在一个对象中并将请求指派给它。Strategy（策略）模式将算法封装在对象中，这样可以方便地指定和改变一个对象所使用的算法。Command（命令）模式将一个请求封装为一个对象，从而使得可以用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。Memento（备忘录）模式在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便在以后可将该对象恢复到原先保存的状态。State（状态）模式封装一个对象的状态，使得对象在其内部状态改变时可改变它的行为，对象看起来似乎修改了它的类。Visitor（访问者）模式表示一个作用于某对象结构中的各元素的操作，使得在不改变各元素的类的前提下定义作用于这些元素的新操作。Visitor模式封装分布于多个类之间的行为。Iterator（迭代器）模式提供一种方法顺序访问一个聚合对象中的各个元素，且不需要暴露该对象的内部表示。Iterator模式抽象了访问和遍历一个集合中的对象的方式。

下面以中介者模式和观察者模式为例进行说明。

Mediator（中介者）

（1）意图。用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

（2）结构。中介者模式的结构图如下图所示。

中介者模式结构图

其中：

.Mediator（中介者）定义一个接口用于各同事（Colleague）对象通信。

.ConcreteMediator（具体中介者）通过协调各同事对象实现协作行为；了解并维护它的各个同事。

.Colleague class（同事类）知道它的中介者对象；每一个同事类对象在需要与其他同事通信的时候与它的中介者通信。

（3）适用性。Mediator模式适用于：

.一组对象以定义良好但是复杂的方式进行通信，产生的相互依赖关系结构混乱且难以理解。

.一个对象引用其他很多对象并且直接与这些对象通信，导致难以复用该对象。

.想定制一个分布在多个类中的行为，而又不想生成太多的子类。

Observer（观察者）

（1）意图。定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

（2）结构。观察者模式的结构图如下图所示。

观察者模式结构图

其中：

.Subject（目标）知道它的观察者，可以有任意多个观察者观察同一个目标；提供注册和删除观察者对象的接口。

.Observer（观察者）为那些在目标发生改变时需获得通知的对象定义一个更新接口。

.ConcreteSubject（具体目标）将有关状态存入各ConcreteObserver对象；当它的状态发生改变时，向它的各个观察者发出通知。

.ConcreteObserver（具体观察者）维护一个指向ConcreteSubject对象的引用；存储有关状态，这些状态应与目标的状态保持一致；实现Observer的更新接口，以使自身状态与目标的状态保持一致。

（3）适用性。Observer模式适用于：

.当一个抽象模型有两个方面，其中一个方面依赖于另一个方面，将这两者封装在独立的对象中以使它们可以各自独立地改变和复用。

.当对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象有待改变时。

.当一个对象必须通知其他对象，而它又不能假定其他对象是谁，即不希望这些对象是紧耦合的。

题号导航 2016年下半年系统架构设计师上午试卷综合知识

本试卷我的完整做题情况



	第54题在手机中做本题