软件设计师——中级第七章面向对象技术-CSDN博客

本文链接：https://blog.csdn.net/qq_43598720/article/details/146177662

软件设计师——中级

7.1 面向对象基础

7.1.1 面向对象的基本概念

面向对象=对象(Object) + 类(Classification) + 继承(Inheritance) + 消息通信(Communication with message)。

对象

在面向对象的系统中，对象是基本运行时的实体，即包括数据（属性），也包括作用于数据的操作（行为）。一个对象把属性和行为封装为一个整体。一个对象一般由对象名（标识）、属性和方法三个部分组成。
消息

对象之间进行通信的一种构造称为消息。消息发送给接收对象，接收对象收到消息后，经过解释予以响应，这种通信机制称为消息传递。对象间的通信靠消息传递。（通过对象引用来实现）
类

类是创建对象的模板，是对对象的抽象；对象是类的具体化，是类的实例。在分析和设计时，通常把注意力集中在类上，而不是具体的对象。
继承

继承是父类与子类之间共享数据和方法的机制。这是类之间的一种关系，在定义和实现一个类的时候，可以在一个已经存在的类的基础上进行，并把这个类所定义的内容作为自己的内容，并加入若干新的内容。
多态

在收到消息时，对象要予以响应。不同的对象收到同一消息可以产生不同的行为结果，这个现象称为多态（polymorphism）。在面向对象设计中，多态性是通过继承和方法重写来实现的。
- 参数多态：采用参数化模板，传递不同类型的对象，执行不同的操作。如C++语言中的函数模板和类模板均属于参数多态。应用比较广泛，被称为最纯的多态。
- 包含多态：最常见的例子就是子类型化，也就是一个类型是另一个类型的子类型（其实就是覆盖）。一般需要进行运行时的类型检查。同样的操作可用于一个类型及其子类型（注意是子类型，不是子类）。如C++语言中的virtual虚函数。
- 过载多态：是指同一个名（操作符、函数名）在不同的上下文中有不同的含义。如C++语言中的运算符重载和函数重载就是过载多态。（其实就是重载）
- 强制多态：是指通过类型转换将一个对象类型视为另一个对象类型的行为。比如，程序设计语言中基本类型的大多数操作符，在对不同类型的数据进行混合运算时，编译程序一般都会进行强制多态。（如不同数据类型相加操作）
动态绑定

绑定是一个把过程调用和响应调用所需要执行的代码加以结合的过程。在编译时进行的绑定，称为静态绑定。在运行时进行的绑定称为动态绑定。

7.1.2 面向对象分析

**面向对象分析（OOA）**的目的是获得对应用问题的理解，以确定系统的功能和性能需求。面向对象分析包括五个活动：

①认定对象；②组织对象；③对象间的相互作用；④定义对象的操作；⑤定义对象的内部信息。

7.1.3 面向对象设计（必考）

**面向对象设计（OOD）**是将OOA所创建的分析模型转化为设计模型，其目标是定义系统构造蓝图。
面向对象设计的原则：

（1）单一职责原则：修改某个类的原因有且只有一个，让一个类只做一种责任。

（2）开放-封闭原则（open-close原则）：对扩展是开放的，对修改是封闭的。

（3）里氏替换原则：子类型必须能够替换父类型。

（4）依赖倒置原则：抽象不应该依赖于细节，细节应该依赖于抽象。即高层模块不应该依赖于底层模块，二者都应该依赖于抽象。

（5）接口分离原则：客户不应该依赖于它不需要的接口，类间的依赖关系应该建立在最小的接口上。

（6）迪米特法则：一个软件实体应当尽可能少的与其他实体发生相互作用。

（7）组合重用原则：要尽量使用组合，而不是继承关系达到重用的目的。

（8）重用发布等价原则：重用的粒度就是发布的粒度。

（9）共同封闭原则：包中的所有类对于同一类性质的变化应该是共同封闭的。一个变化若对一个包产生影响，则将对该包中的所有类产生影响，而对于其他的包不造成任何影响。

（10）共同重用原则：一个包中的所有类应该是共同重用的。如果重用了包中的一个类，那么就要重用包中的所有类。

（11）无环依赖原则：在包的依赖关系图中不允许存在环，即包之间的结构必须是一个直接的无环图形。

（12）稳定依赖原则：朝着稳定的方向进行依赖。

（13）稳定抽象原则：包的抽象程度应该和其稳定程度一致。

7.1.4 面向对象程序设计

**面向对象程序设计（OOP）**的实质是选用一种面向对象程序设计语言（OPPL），采用对象、类及其相关概念所进行的程序设计。它的关键在于加入了类和继承性，从而进一步提高了抽象程度。

类

通常我们总是先引入对象的概念，然后从对对象进行抽象的角度来引入类的概念。但当设计和实现一个面向对象程序时，首先接触到的不是对象，而是类和类层次结构。
继承和类层次结构

继承是父类与子类之间共享数据和方法的机制。在面向对象系统中，子类和父类之间的继承关系构成了这个系统的类层次结构，可以用树（对应于单继承）或格（对应于多继承）这样的图来描述。

生成实例对象时，自顶向下执行构造方法，父类构造方法->子类构造方法；销毁实例对象时，自底向上执行消除方法，子类消除方法->父类消除方法。
对象、消息传递和方法

对象是类的实例。对象的表示在形式上与一般数据类型十分相似，但是它们之间存在着本质区别：对象之间通过消息传递的方式进行通信。
对象自身引用

对象自身引用（self-reference）是OOPL中的一种特有结构。这种结构在不同的OOPL中有不同的名称，在C++和java中称为this，在python、Object-C和一些其他OOPL中称为self。
重置

也称覆盖（重写，overriding），是在子类中重新定义父类中已经定义的方法。

（重载：在一个类中，允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同））
类属类

类属是程序设计语言中普遍注重的一种参数多态机制，在OOPL中也不例外。值得注意的是，在C++语言中，类属有专门的术语template。类属类可以看成是类的模板。
无实例的类

类是创建对象的模板，而对象是类的实例。在C++和java语言中，可以定义抽象类。抽象类不用来进行实例化，而是用来被继承所使用。

7.1.5 面向对象测试

面向对象测试可以分为四个层次：

（1）算法层。用于测试类中定义的每个方法，基本上相当于传统软件测试中的单元测试。

（2）类层。用于测试封装在同一个类中的所有方法与属性之间的相互作用。在面向对象软件中，类是基本模块，因此可以认为这是面向对象测试中所特有的模块测试。

（3）模版层。用于测试一组协同工作的类之间的相互作用。大体上相当于传统软件测试中的集成测试，但是也有面向对象软件的特点，如对象之间通过发送消息相互作用。

（4）系统层。把各个子系统组装成完整的面向对象软件系统，在组装过程中同时进行测试。

7.2 UML（重点）

UML（Unified Modeling Language，统一建模语言）是面向对象软件的标准化建模语言。包含3种构造块：事务、关系和图。事务是UML中最基本的构成元素；关系把事物结合在一起；图聚集了相关的事务。

7.2.1 事务

UML中有4种事务：结构事务、行为事务、分组事务、注释事务。
- 结构事务：是模型的静态部分。描述UML模型的概念或物理元素，包括类（Class）、接口（Interface）、协作（Collaboration）、用例（Use Case）、主动类*Active Class）、构建（Component）、制品（Artifact）和结点（Node）。
- 行为事务：是模型的动态部分。描述一种跨越时间和空间的行为。包括交互、状态机（State Machine）和活动（Activity）。
- 分组事务：是UML模型的组织部分。在所有的分组事务中，最主要的分组事务是包（Package）。包是把元素组织成组的机制，结构事务、行为事务甚至其他分组事务都可以放进包内。
- 注释事务：是UML模型的解释部分。一般用来描述、说明和标注模型的任何元素。

7.2.2 关系（掌握）

UML中有四种关系：依赖、关联、泛化和实现，如下表所示。

7.2.3 UML中的图

图（Diagram）是事务和关系的可视化表示。在UML2.0中总共定义了13种图，如下图所示。(类图和用例图是重点)
1. 类图
  
  描述类、类的特性以及类之间的关系。类图中包含的内容如下图所示。
2. 用例图
  
  描述了一组用例、参与者以及它们之间的关系。也就是描述系统与外部系统及用户的交互，用图形描述谁将使用系统，用户期望用什么方法与系统交互。常用于系统语境建模、系统需求建模）
  
  用例之间的关系有3种：①包含关系。当可以从两个或两个以上的用例中提取公共行为时，应该使用包含关系来表示它们，用 << include>> 表示。② 扩展关系 。如果一个用例明显地混合了两种或两种以上的不同场景，即根据情况可能发生 多种分支 ，则可以将这个用例分为一个基本用例和一个或多个扩展用例，这样的描述可能更加清晰，用<< extend>>表示。③ 泛化关系。当多个用例共同拥有一种类似的结构和行为的时候，可以将它们的共性抽象成为父用例，其他的用例作为泛化关系中的子用例。
  
  如：
  
  学生登记用例：
  
  Seminar：研讨课
  
  包含关系：有公共的行为：登记
  
  扩展关系：明显地混合了两种或两种以上的不同场景，即根据情况可能发生多种分支。
  
  学生登记为基本用例，安全检查为扩展用例。
  
  泛化关系：登记学生和登记学生家庭成员共同拥有一种类似的结构和行为，即登记信息，这就是泛化关系。
3. 顺序图
  
  又称序列图，描述对象之间的交互（消息的发送与接收），重点在于强调顺序，反映对象间消息的发送与接收。
  
  数据库使用数据库代理的顺序图：
  
  在顺序图中，首先把参加交互的对象放在图的最上方，沿水平方向排列。通常把发起交互的对象放在左边，下级对象依次放在右边。然后把这些对象发送和接收的消息沿垂直方向按时间顺序从上到下放置。这样，就提供了控制流随时间推移的清晰的可视化轨迹。
4. 活动图
  
  描述过程行为和并行行为。
  
  它是一种特殊的状态图，展现了在系统内从一个活动到另一个活动的流程，对于系统的功能建模特别重要，并强调对象间的控制流程。
5. 状态图
  
  描述对象状态及其转换。状态图就是一个状态机，由状态、转换、事件和活动组成。状态是指对象的生命周期中某个条件或者状态。状态图关注系统的动态视图，强调对象行为的事件顺序。
  
  这是一个接电话的状态图，状态图的状态通常包括简单状态和组合状态（含有子状态的状态称为组合状态），除此之外状态图中还有转换、事件。
6. 对象图
  
  描述了某一时刻一组对象和它们之间的关系。
7. 通信图
  
  交互图：用于对系统的动态方面进行建模。一张交互图表现的是一个交互，由一组对象和它们之间的关系组成，包含它们之间可能传递的消息。交互图可以分为顺序图（序列图）、通信图、交互概览图和时序图。
  
  通信图：强调收发信息的对象的结构组织，在早期版本中也被称为协作图，强调参加交互的对象的组织。通信图有两个不同于顺序图的特征：通信图有路径；通信图有顺序号。
8. 交互概览图
  
  它是活动图的变体，描述业务过程中的控制流概览、软件过程中的详细逻辑概览及多个图进行拼接，抽象掉信息和生命线，属于顺序图与活动图的混合。
9. 时序图
  
  又称计时图，是一种新增的、特别适合实时嵌入式系统建模的交互图。其关注沿着线性时间轴、生命线内部和生命线之间的条件改变。它描述对象的状态随着时间改变的情况，很像示波器。
10. 构件图
  
  描述了一组构件之间的组织和依赖关系，专注于系统的静态实现视图。
11. 组合结构图
  
  描述了一个分类器（如类、构件等）的内部结构，分类器与系统中其他组成部分之间的交互端口，展示一组相互协作的实例如何完成特定的任务，描述设计、架构模式或策略。
12. 部署图
  
  描述了各个节点上的部署，展现了系统中软、硬件之间的物理关系。
13. 包图
  
  包图用于把模型本身组织成层次结构的通用机制，不能执行，展现由模型本身分解而成的组织单元及之间的依赖关系。包可以拥有其他元素，可以是类、接口、构建、结点、协作、用例和图，甚至是嵌套的其他包。一个元素只能被一个包拥有，拥有关系的包形成了一个命名空间，其中同一种元素的名称必须唯一。

7.3 设计模式（掌握）

7.3.1 设计模式的要素

模式是对特定问题的解决方案。设计模式的核心在于提供了相关问题的解决方案，使人们可以更加简单方便地复用成功的设计和体系结构。设计模式是前人通过开发经验对特定的代码进行设计，编写总结出来的一套解决特定问题的方案，来提高代码的可维护性、可重用性、可理解性、可靠性等。设计模式的四个基本要素为：①模式名称；②问题；③解决方案；④效果。
创建型设计模式与对象的创建有关；结构型设计模式处理类或对象的组合；行为型设计模式对类或对象怎样交互和怎样分配职责进行描述。
设计模式的优点：
1. 是前人经验的总结，可以降低开发人员理解系统的复杂度；
2. 可以方便地复用成功的设计和体系结构；
3. 使设计方案更加灵活，且易于修改；
4. 提高软件的开发效率和软件质量，提高设计水平；
5. 有助于更加深入地理解面向对象思想。

（补充）抽象类与接口的区别

区别	抽象类	接口
结构组成	普通方法+抽象方法	抽象方法+全局变量
权限	各种权限	public
子类使用	使用extends关键字继承抽象类	使用implements关键字实现接口
关系	一个抽象类可以实现若干接口	接口不能继承抽象类，但是接口可以使用extends关键字继承多个父接口
子类限制	一个子类只能继承一个抽象类	一个子类可以实现多个接口
应用场景	抽象不同事务的共有特性、本质	抽象不同事务的共有行为、操作

7.3.2 创建型设计模式

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

将对象的创建和对象的使用分离，在使用对象时无需知道对象创建的细节，使设计更加符合单一职责原则，降低了系统的耦合性，且易于扩展，包括：①抽象工厂模式（Abstract Factory）；②生成器模式（Builder）；③工厂方法模式（Factory Method）；④原型模式（Prototype）；⑤单例模式（Singleton）。

抽象工厂模式（Abstract Factory）
- 定义：提供一个创建一系列相关或相互依赖的对象的接口，而无需指定它们具体的类。
- 分类：创建型对象模式。
- 适用场景：①一个系统要独立于它的产品的创建、组合和表示时。
  
  ②一个系统要由多个产品系列中的一个来配置时。
  
  ③当要强调一系列相关的产品对象的设计以便进行联合使用时。
  
  ④当提供一个产品类库，只想显示它们的接口而不是实现时。
生成器模式（Builder）
- 定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
- 分类：创建型对象模式。
- 适用场景：①当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
  
  ②当构造过程必须允许被构造的对象有不同的表示时。
工厂方法模式（Factory Method）
- 定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。使一个类的实例化延迟到其子类。
- 分类：创建型类模式。
- 适用场景：①当一个类不知道它所必须创建的对象的类的时候。
  
  ②当一个类希望由它的子类来指定它所创建的对象的时候。
  
  ③当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
原型模式（Prototype）
- 定义：用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。
- 分类：创建型对象模式。
- 适用场景：①当一个系统应该独立于它的产品创建、构成和表示时。
  
  ②当要实例化的类是在运行时刻指定时，例如，通过动态装载。
  
  ③为了避免创建一个与产品类层次平行的工厂类层次时。
  
  ④当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们，可能比每次用合适的状态手工实例化该类更方便一些。

单例模式（Singleton）

定义：保证一个类只有一个实例，并提供了一个访问它的全局访问点。
分类：创建型对象模式。

适用场景：①当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。

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

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

7.3.3 结构型设计模式

主要用于处理类或对象的组合。

分为结构型类模式和结构型对象模式，在结构型类模式中主要是类的继承和实现，在结构型对象模式中主要是类与对象的关联关系，根据组合重用原则，大部分结构型模式是结构型对象模式，包括：①适配器模式（Adapter）；②桥接模式（Bridge）；③组合模式（Composite）；④装饰模式（Decorator）；⑤外观模式（Facade）；⑥享元模式（Flyweight）；⑦代理模式（proxy）。

适配器模式可以是结构型类模式也可以是结构型对象模式，其他均为结构型对象模式。

适配器模式（Adapter）
- 定义：将一个类的接口转换成客户希望的另一种接口。它使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
- 分类：结构型类模式或结构型对象模式。
- 适用场景：①想适用一个已经存在的类，而它的接口不符合要求。
  
  ②想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。
  
  ③（仅适用于对象Adapter）想使用一个已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。
桥接模式（Bridge）
- 定义：将抽象部分与其实现部分分离，使它们都可以独立的变化。
- 分类：结构型对象模式。
- 适用场景：①不希望在抽象和它的实现部分之间有一个固定的绑定关系。
  
  ②类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。
  
  ③对一个抽象的实现部分的修改应对客户不产生影响，即客户代码不必重新编译。
  
  ④（C++）想对客户完全隐藏抽象的实现部分。
  
  ⑤有许多类要生成的类层次结构。
  
  ⑥想在多个对象间共享实现（可能使用引用计数），但同时要求客户并不知道这一点。
组合模式（Composite）
- 定义：将对象组合成树型结构以表示“部分-整体”的层次结构，它使得用户对单个对象和组合对象的使用具有一致性。
- 分类：结构型对象模式。
- 适用场景：①想表示对象的部分-整体层次结构。
  
  ②希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。
装饰模式（Decorator）
- 定义：动态地给一个对象添加一些额外的职责。
- 分类：结构型对象模式。
- 适用场景：①在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
  
  ②处理那些可以撤销的职责。
  
  ③当不能采用生成子类的方式进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是，由于类定义被隐藏，或类定义不能用于生成子类。
外观模式（Facade）
- 定义：为子系统中的一组接口提供一个一致的界面，它定义了一个高层接口，这个接口使得这一子系统更加容易使用。
- 分类：结构型对象模式。
- 适用场景：①要为一个复杂子系统提供一个简单接口时，Facade可以提供一个简单的默认视图。
  
  ②客户程序与抽象类的实现部分之间存在着很大的依赖性。引入Facade将这个子系统与客户以及其他的子系统分离，可以提高子系统的独立性和可移植性。
  
  ③当需要构建一个层次结构的子系统时，使用Facade模式定义子系统中每层的入口点。如果子系统之间时相互依赖的，则可以让它们仅通过Facade进行通信，从而简化了它们之间的依赖关系。
享元模式（Flyweight）
- 定义：运用共享技术有效地支持大量细粒度的对象。
- 分类：结构型对象模式。
- 适用场景：①一个应用程序使用了大量的对象。
  
  ②完全由于适用大量的对象，造成很大的存储开销。
  
  ③对象的大多数状态都可变为外部状态。
  
  ④如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象。
  
  ⑤应用程序不依赖于对象标识。由于Flyweight对象可以被共享，所以对于概念上明显有别的对象，标识测试将返回真值。

代理模式（Proxy）

定义：为其他对象提供一种代理以控制对这个对象的访问。
分类：结构型对象模式。

适用场景：①远程代理（Remote Proxy）为一个对象在不同地址空间提供局部代表。

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

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

④智能引用（Smart Reference）取代了简单的指针，它在访问对象时执行一些附加操作。

结构型设计模式	定义	记忆口诀
适配器模式（Adapter）	将一个类的接口转换成客户希望的另一种接口。它使得原本由于接口不兼容而不能一起工作的那些类可以一起工作	转换成兼容接口
桥接模式（Bridge）	将抽象部分与其实现部分分离，使它们都可以独立的变化	抽象与实现分离
组合模式（Composite）	将对象组合成树型结构以表示“部分-整体”的层次结构，它使得用户对单个对象和组合对象的使用具有一致性	树型结构
装饰模式（Decorator）	动态地给一个对象添加一些额外的职责	额外的职责
外观模式（Facade）	为子系统中的一组接口提供一个一致的界面，它定义了一个高层接口，这个接口使得这一子系统更加容易使用	一致的界面
享元模式（Flyweight）	运用共享技术有效地支持大量细粒度的对象	共享
代理模式（Proxy）	为其他对象提供一种代理以控制对这个对象的访问	代理

7.3.4 行为型设计模式

主要描述类或对象的交互行为。
用于描述对类或对象怎样交互和怎样分配职责，包括：①责任链模式（Chain of Responsibility）；②命令模式（Command）；③解释器模式（Interpreter）；④迭代器模式（Iterator）；⑤中介者模式（Mediator）；⑥备忘录模式（Memento）；⑦观察者模式（Observer）；⑧状态模式（State）；⑨策略模式（Strategy）；⑩模版方法模式（Template Method）；⑪访问者模式（Visitor）。

责任链模式（Chain of Responsibility）
- 定义：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象**（连成一条链）**，并沿着这条链传递该请求，直到有一个对象处理它为止。
- 分类：行为型对象模式。
- 适用场景：①有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
  
  ②想在不明确指定接受者的情况下向多个对象中的一个提交一个请求。
  
  ③可处理一个请求的对象集合应被动态指定。
命令模式（Command）
- 定义：将一个请求封装为一个对象，从而使得可以用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。
- 分类：行为型对象模式。
- 适用场景：①抽象出待执行的动作以参数化某对象。
  
  ②在不同的时刻指定、排列和执行请求。
  
  ③支持取消操作。
  
  ④支持修改日志。
  
  ⑤用构建在原语操作上的高层操作构造一个系统。
解释器模式（Interpreter）
- 定义：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器适用该表示来解释语言中的句子。
- 分类：行为型类模式。
- 适用场景：①当有一个语言需要解释执行，并且可将该语言中的句子表示为一个抽象语法树时。
迭代器模式（Iterator）
- 定义：提供一种方法顺序访问一个聚合对象中的各个元素，且不需要暴露该对象的内部表示。
- 分类：行为型对象模式。
- 适用场景：①访问一个聚合对象的内容而无须暴露它的内部表示。
  
  ②支持对聚合对象的多种遍历。
  
  ③为遍历不同的聚合结构提供一个统一的接口。
中介者模式（Mediator）
- 定义：用一个中介对象来封装一系列的对象交互。它使各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
- 分类：行为型对象模式。
- 适用场景：①一组对象以定义良好但是复杂的方式进行通信，产生的相互依赖关系结构混乱且难以理解。
  
  ②一个对象引用其他很多对象并且直接与这些对象通信，导致难以复用该对象。
  
  ③想定制一个分布在多个类中的行为，而又不想生成太多的子类。
备忘录模式（Memonto）
- 定义：在不破坏封装性的前提下捕获一个对象的内部状态，并在对象之外保存这个状态。这样以后就可以将对象恢复到原先保存的状态。
- 分类：行为型对象模式。
- 适用场景：①必须保存一个对象在某一个时刻的（部分）状态，这样以后需要时它才能恢复到先前的状态。
  
  ②如果一个用接口来让其他对象直接得到这些状态，将会暴露对象的实现细节并破坏对象的封装性。
观察者模式（Observer）
- 定义：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。
- 分类：行为型对象模式。
- 适用场景：①当一个抽象模型有两个方面，其中一个方面依赖于另一个方面，将这两者封装在独立的对象中以使它们可以各自独立地改变和复用。
  
  ②当对一个对象的改变需要同事改变其他对象，而不知道具体有多少对象有待改变时。
  
  ③当一个对象必须通知其他对象，而它又不能假定其他对象是谁，即不希望这些对象是紧耦合的。
状态模式（State）
- 定义：允许一个对象在其内部状态改变时改变它的行为。
- 分类：行为型对象模式。
- 适用场景：①一个对象的行为决定于它的状态，并且它必须在运行时刻根据状态改变它的行为。
  
  ②一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。这个状态常用一个或多个枚举常量表示。通常，有多个操作包含这一相同的条件结构。State模式将每一个条件分支放入一个独立的类中。这使得开发者可以根据对象自身的情况将对象的状态作为一个对象，这一对象可以不依赖于其他对象独立变化。
策略模式（Strategy）
- 定义：定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。它使得算法可以独立于使用它们的客户而变化。
- 分类：行为型对象模式。
- 适用场景：①许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为中的一个行为来配置一个类的方法。
  
  ②需要适用一个算法的不同变体。
  
  ③算法使用客户不应该知道的数据。可使用策略模式以避免暴露复杂的、与算法相关的数据结构。
  
  ④一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现，将相关的条件分支移入它们各自的Strategy类中，以代替这些条件语句。
模板方法模式（Template Method）
- 定义：定义一个操作中的算法骨架，而将一些步骤延迟到子类中。它使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。
- 分类：行为型类模式。
- 适用场景：①一次性实现一个算法的不变部分，并将可变的行为留给子类来实现。
  
  ②各子类中公共的行为应被提取出来并集中到一个公共父类中，以避免代码重复。
  
  ③控制子类扩展。模板方法旨在特定点调用“hook”操作（默认的行为，子类可以在必要时进行重定义扩展），这就只允许在这些点进行扩展。
访问者模式（Visitor）
- 定义：表示一个作用于某对象结构中的各元素的操作。它允许在不改变各元素的类的前提下定义作用于这些元素的新操作。
- 分类：行为型对象模式。
- 适用场景：①一个对象结构包含很多类对象，它们有不同的接口，而用户想对这些对象实施一些依赖于其具体类的操作。
  
  ②需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而又想要避免这些操作“污染”这些对象的类。
  
  ③定义对象结构的类很少改变，但经常需要在此结构上定义新的操作。

行为型设计模式	定义	记忆口诀
责任链模式（Chain of Responsibility）	使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象（连成一条链），并沿着这条链传递该请求，直到有一个对象处理它为止	机会连成一条链
命令模式（Command）	将一个请求封装为一个对象，从而使得可以用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作	参数化
解释器模式（Interpreter）	给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器适用该表示来解释语言中的句子	解释器
迭代器模式（Iterator）	提供一种方法顺序访问一个聚合对象中的各个元素，且不需要暴露该对象的内部表示	顺序访问
中介者模式（Mediator）	用一个中介对象来封装一系列的对象交互。它使各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互	中介对象
备忘录模式（Memonto）	在不破坏封装性的前提下捕获一个对象的内部状态，并在对象之外保存这个状态。这样以后就可以将对象恢复到原先保存的状态	保存状态
观察者模式（Observer）	定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新	自动更新
状态模式（State）	允许一个对象在其内部状态改变时改变它的行为	状态改变
策略模式（Strategy）	定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。它使得算法可以独立于使用它们的客户而变化	算法相互替换
模板方法模式（Template Method）	定义一个操作中的算法骨架，而将一些步骤延迟到子类中。它使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤	重新定义算法
访问者模式（Visitor）	表示一个作用于某对象结构中的各元素的操作。它允许在不改变各元素的类的前提下定义作用于这些元素的新操作	新操作

设计模式分类

	创建型	结构型	行为型
类	工厂方法模式	适配器模式（类）	解释器模式模板方法模式
对象	抽象工厂模式生成器模式原型模式单例模式	适配器模式（对象）桥接模式组合模式装饰模式外观模式享元模式代理模式	责任链模式命令模式迭代器模式中介者模式备忘录模式观察者模式状态模式策略模式访问者模式