程序中的设计模式设计都有哪些原则呢？

导读：" 程序中的设计模式设计都有哪些原则呢？1.单一职责原则（SingleResponsibilityPrinciple）：一个类应该只负责一项职责。这样可以使类的设计更加简单、可维护性更高，同时也能减少类之间的耦合度。2.开放封闭原则（Open-ClosedPrinciple）：软件实体应该对扩展开放，对修改封闭。即通过扩展"

程序中的设计模式设计都有哪些原则呢？

　　1.单一职责原则（SingleResponsibilityPrinciple）：一个类应该只负责一项职责。这样可以使类的设计更加简单、可维护性更高，同时也能减少类之间的耦合度。

　　2.开放封闭原则（Open-ClosedPrinciple）：软件实体应该对扩展开放，对修改封闭。即通过扩展已有的代码来适应新的需求，而不是直接修改已有的代码。

　　3.里氏替换原则（LiskovSubstitutionPrinciple）：子类应该能够替换掉父类，并且不影响程序的正确性。使用者只需要关注父类的接口定义，而不需要关心具体的子类实现。

　　4.依赖倒置原则（DependencyInversionPrinciple）：高层模块不应该依赖低层模块，二者都应该依赖于抽象。通过引入抽象接口，可以降低模块之间的耦合度，提高代码的灵活性和复用性。

　　5.接口隔离原则（InterfaceSegregationPrinciple）：客户端不应该强迫依赖它不需要的接口。一个类应该只依赖于它需要的接口，而不是依赖于不需要的接口。

　　6.迪米特法则（LawofDemeter）：一个对象应该对其他对象有尽可能少的了解。通过减少对象之间的依赖关系，可以降低耦合度，提高代码的可维护性和扩展性。

　　7.组合/聚合复用原则（Composite/AggregateReusePrinciple）：优先使用组合/聚合关系，而不是继承关系来实现代码复用。组合/聚合关系更加灵活，可以在运行时动态地改变对象的行为。

　　总结起来，程序中的设计模式设计应该遵循单一职责原则、开放封闭原则、里氏替换原则、依赖倒置原则、接口隔离原则、迪米特法则和组合/聚合复用原则。

　　这些原则能够提高代码的可读性、可维护性和可扩展性，从而使程序更加健壮和可靠。

　　同时，不同的设计模式也可以根据具体的需求选择使用，以提供更加灵活和高效的解决方案。

软件设计原则有哪些

七大设计原则

开闭原则

依赖导倒置原则

单一职责原则

接口隔离原则

迪米特原则

里氏替换原则

合成复用原则

设计模式-创建型模式

工厂方法模式

抽象工厂模式

建造者模式

单例模式

原型模式

设计模式-结构性模式

适配器模式轿亩山

装饰者模式

代理模式

外观模式

桥接模式

组合模式

享元模式

设计模式-行为型模式

策略模式

模板方法模式

观察者模式

访问者模式

迭代器模式

责任链模式

中介者模式

解释器模式

状态模式

命令模式

备忘录模式

软件设计原则介绍

　　所以，可以说软件系统是连接需求分析、硬件系统以及使得系统实现的桥梁，对软件的设计应首先了解软件设计的设计原则。

设计原则

(1)可靠性

　　软件系统的规模越做越大越加复杂，其可靠性越来越难保证。

　　应用本身对系统运行的可靠性要求越来越高，软件系统的可靠性也直接关系到设计自身的声誉和生存发展竞争能力。

　　软件可靠性意味着该软件在测试运行过程中避免可能发生故障的能力，且一旦发生故障后，具有解脱和排除故障的能力。

　　软件可靠性和硬件可靠性本质区别在于：后者为物理机理的衰变和老化所致，而前者是由于设计和实现的错误所致。

　　故软件的耐侍可靠性必须在设计阶段就确定，在生产和测试阶段再考虑就困难了。

(2)健壮性

　　健壮性又称鲁棒性，是指软件对于规范要求以外的输入能够判断出这个输入不符合规范要求，并能有合理的处理方式。

　　软件健壮性是一个比较模糊的概念，但是却是非常重要的软件外部量度标准。

　　软件设计的健壮与否直接反应了分析设计和编码人员的水平。

(3)可修改性

　　要求以科学的方法设计软件，使之有良好的结构和完备的文档，系统性能易于调整。

(4)容易理解

　　软件的可理解性是其可靠性和可修改性的前提。

　　它并不仅仅是文档清晰可读的问题，更要求软件本身具有简单明了的结构。

　　这在很大程度上取决于设计者的洞察力和创造性，以及对设计对象掌握得透彻程度，当然它还依赖于设计工具和方法的适当运用。

(5)程序简便

(6)可测试性

　　可测试性就是设计一个适当的数据集合，用来测试所建立的系统，并保证系统得到全面的检验。

(7)效率性

　　软件的效率闭中性一般用程序的执行时间和所占用的内存容量来度量。在达到原理要求功能指标的前提下，程序运行所需时间愈短和占用存储容量愈小，则效率愈高。

(8)标准化原则

　　在结构上实现开放，基于业界开放式标准，符合国家和信息产业部的规范。

(9)先进性

　　满足客户需求，系统性能可靠，易于维护。

(10)可扩展性

　　软件设计完要留有升级接口和升级空间。对扩展开放，对修改关闭。

（11）安全性

　　安全性要求系统能够保持用户信息、操作等多方面的安全要求，同时系统本身也要能够及时修复、处理各种安全漏洞，以提升安全性能。

设计模式有几个原则?分别是什么

　　职责原则(SingleResponsibilityPrinciple,SRP)：类的职责要单一，不能将太多的职责放在一个类中。（高内聚、低耦合）

2.开闭原则(Open-ClosedPrinciple,OCP)：对扩展开放，对修改关闭（设旦塌计模式的核心原则是）

3.依赖倒转原则(DependenceInversionPrinciple,DIP)：要依赖抽象,而不要依赖具体的模拆圆实现.

4.里氏代换原御答则(Lisk

软件设计应遵循的原则是什么?

关于软件设计应遵循的原则是什么，相关内容如下：

一、开闭原则（OpenClosedPrinciple，OCP）：

　　当应用的需求改变时，在不修改软件实体的源代码或者二进制代码的前提下，可以扩展模块的功能，使其满足新的需求。

　　通过重新父类的方法来完成新的功能写起来写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多肽比较频繁时，程序运行出错的概率会非常大。

二、里氏替换原则（LiskovSubstitutionPrincipleLSP）：

　　子类可以扩展父类的功能，但不能改变父类原有的功能。也就是说：子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。

三、依赖倒置原则（DependencyInversePrincipleDIP）：

　　高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象，其核心思想要面向接口编程，不要面向实现编程。

　　（1）每个类尽量提供接口或抽象类，或者两者都具备。

　　（2）变量的声明类型尽量是接口或者是抽象类。

　　（3）任何类都不应该从具体类派生。

　　（4）使用继承时尽量遵循里氏替换原则。

四、单一职责原则（SingleResponsibilityPrinciple，SRP）：

　　发现类的不同职责并将其分喊拍离，再封装到不同的类或模块中。

五、接口隔离原则（InterfaceSegregationPrinciple，ISP）：

　　尽量将臃肿庞大的接口拆分成更小的和更具体的接口，让接口中只包含客户感兴趣的方法。

六、迪米特法则（LawofDemeter，LoD）：

　　如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。

　　（1）在类的划分上，应该创建弱耦合的类。

　　类与类之间的耦合越弱，就越有利于实现可复用的目标。

　　。

　　（2）在类的结构设计上，尽量降低类成员的访问权限。

　　（3）在类的设计上，优先考虑将一个类设置成不变类。

　　（4）在对其他类的引用上，将引用其他对象的次数降到最低。

　　（5）不暴露类的属性成员，而应该提供相应的访问器（set和get方法）。

　　（6）谨慎使用序列化（Serializable）功能。

七、合成复用原则（CompositeReusePrinciple，CRP）：

　　如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。

　　这7种设计原则是软件设计模式必须尽量遵循的原则，各种原则要求的侧重点不同。其中，开闭原则是总纲，它告诉我们要对扩展开放，对修改关闭；里氏替换原郑含羡则告诉我们不要破坏继承体系；依赖倒置原则告诉我们要面向接口编程；

　　单一职责原则告诉我们实现类要职责单一；接口隔离原则告诉我们老禅在设计接口的时候要精简单一；迪米特法则告诉我们要降低耦合度；合成复用原则告诉我们要优先使用组合或者聚合关系复用，少用继承关系复用。

软件设计的通用原则有哪些

软件碰拿设计的通用原则如下：

　　（1）软件设计的一条最重要原则，就是模块独立性原则。

　　（2）尽量提高模块内的聚合性，降低模块间的耦合性。

　　（3）适度控制模块的规模。

　　（4）信息隐藏和局部化的原则。

　　（5）抽象的原则。

　　（6）控制层次适中的原则。

软件专业就业方向：

　　软件工程专业学生毕业后可在计算机软件专业公司﹑信息咨询公司﹑宴肢以及金融等其它独资、合资企业从事软件工程师、项目经理、软件开发工程师、测试工程师、java开发工程师等工作；主要的工在就业机会比较多的北京、上海、深圳、广州、杭州、武汉等城市。

软件工程专业学习课程：

　　软件工程专业学习的课程有C/C 程序设计、Java语言程序设计、软件工程、电路与模晌吵世拟电子技术、Linux操作系统与网络编程、WEB技术与应用、数据结构与算法、数据库开发技术、算法分析、人工智能技术、Oracle数据库设计与开发、UNIX/LINUX操作系统、软件体系架构与设计模式、传感网理论与互联网技术。

设计模式的设计原则

　　为什么要提倡“DesignPattern呢？根本原因是为了代码复用，增加可维护性。

　　那么怎么才能实现代码复用呢？面向对象有几个原则：单一职责原则（SingleResponsiblityPrincipleSRP）开闭原则（OpenClosedPrinciple，OCP）、里氏代换原则（LiskovSubstitutionPrinciple，LSP）、依赖倒转原则（DependencyInversionPrinciple，DIP）、接口隔离原则（InterfaceSegregationPrinciple，ISP）、合成/聚合复用原则（Composite/AggregateReusePrinciple，CARP）、最小知识原则（PrincipleofLeastKnowledge，PLK，也叫迪米特法则）。

　　开闭原则具有理想主义的色彩，它是面向对象设计的终极目标。

　　其他几条，则可以看做是开闭原则的实现方法。

　　设计模式就是实现了这些原则，从而达到了代码复用、增加可维护性的目的。

　　此原则是由BertrandMeyer提出的。

　　原文是：“Softwareentitiesshouldbeopenforextension,butclosedformodification”。

　　就是说模块应对扩展开放，而对修改关闭。

　　模块应尽量在不修改原（是“原”，指原来的代码）代码的情况下进行扩展。

　　那么怎么扩展呢？我们看工厂模式“factorypattern”：假设中关村有一个卖盗版盘和毛片的小子，我们给他设计一“光盘销售管理软件”。

　　我们应该先设计一“光盘”接口。

　　如图：。

[pre]

______________

|<>|

|光盘|

|_____________|

| 卖()|

||

|_____________|

[/pre]

　　而盗版盘和毛片是其子类。

　　小子通过“DiscFactory”来管理这些光盘。

　　代码为：publicclassDiscFactory{publicstatic光盘getDisc(Stringname){return(光盘)Class.forName(name).newInstance();}}有人要买盗版盘，怎么实现呢？publicclass小子{publicstaticvoidmain(String[]args){光盘d=DiscFactory.getDisc(盗版盘);d.卖();}}如果有一天，这小子良心发现了，开始卖正版软件。

　　没关系，肢袜我们只要再创建一个“光盘”的子类“正版软件”就可以了，不需要修改原结构和代码。

　　怎么样？对扩展开放，对修改关闭——“开闭原则”。

　　工厂模式历返激是对具体产品进行扩展，有的项目可能需要更多的扩展性，要对这个“工厂”也进行扩展，那就成了“抽象工厂模式”。

　　合成/聚合复用原则（Composite/AggregateReusePrinciple，CARP）经常又叫做合成复用原则。

　　合成/聚合复用原则就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分；新的对象通过向这些对象的委派达到复用已有功能的目的。

　　它的设计原则是：要尽量使用合成/聚合，尽量不要使用继承。

　　就是说要少用继承，多用合成关系来实现。

　　我曾经这样写过程序：有几个类要与数据库打交道，就写了一个数据库操作的类，然后别的跟数据库打交道的类都继承这个。

　　结果后来，我修改了数据库操作类的一个方法，各个类都需要改动。

　　“牵一发而动全身”！面向对象是要把波动限制在尽量小的范围。

　　在Java中，应尽量针对Interface编程，而非实现类。

　　这样，更换子类不会影响调用它方法的代码。

　　要让各个类尽可能少的跟别人联系，“不要与陌生人说话”。

　　这样，城门失火，才不至于殃及池鱼。

　　扩展性和维护性才能提高。

　　设计模式分为三种类型，共23种。

　　创建型模式：单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。

　　结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

　　行为型模式：模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器世启模式（Interpreter模式）、状态模式、策略模式、职责链模式(责任链模式)、访问者模式。

　　按字典序排列简介如下。

　　AbstractFactory（抽象工厂模式）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

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

　　Bridge（桥接模式）：将抽象部分与它的实现部分分离，使它们都可以独立地变化。

　　Builder（建造者模式）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

　　ChainofResponsibility（责任链模式）：为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。

　　Command（命令模式）：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可取消的操作。

　　Composite（组合模式）：将对象组合成树形结构以表示“部分-整体”的层次结构。它使得客户对单个对象和复合对象的使用具有一致性。

　　Decorator（装饰模式）：动态地给一个对象添加一些额外的职责。就扩展功能而言，它比生成子类方式更为灵活。

　　Facade（外观模式）：为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

　　FactoryMethod（工厂模式）：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。FactoryMethod使一个类的实例化延迟到其子类。

　　Flyweight（享元模式）：运用共享技术有效地支持大量细粒度的对象。

　　Interpreter（解析器模式）：给定一个语言,定义它的文法的一种表示，并定义一个解释器,该解释器使用该表示来解释语言中的句子。

　　Iterator（迭代器模式）：提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。

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

　　Memento（备忘录模式）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到保存的状态。

　　Observer（观察者模式）：定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新。

　　Prototype（原型模式）：用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。

　　Proxy（代理模式）：为其他对象提供一个代理以控制对这个对象的访问。

　　Singleton（单例模式）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

　　单例模式是最简单的设计模式之一，但是对于Java的开发者来说，它却有很多缺陷。

　　在九月的专栏中，DavidGeary探讨了单例模式以及在面对多线程（multi-threading）、类装载器（classloaders）和序列化（serialization）时如何处理这些缺陷。

　　State（状态模式）：允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它所属的类。

　　Strategy（策略模式）：定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。本模式使得算法的变化可独立于使用它的客户。

　　TemplateMethod（模板方法模式）：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。TemplateMethod使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

　　Visitor（访问者模式）：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

　　从下一节开始，详细描述以下每一种设计模式。意图

　　定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。

　　适用性当一个类不知道它所必须创建的对象的类的时候。

　　当一个类希望由它的子类来指定它所创建的对象的时候。

　　当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

　　意图。

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

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

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

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

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

　　意图。

　　将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

　　适用性当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。

　　当构造过程必须允许被构造的对象有不同的表示时。

　　意图。

　　用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

　　适用性当要实例化的类是在运行时刻指定时，例如，通过动态装载；或者为了避免创建一个与产品类层次平行的工厂类层次时；或者当一个类的实例只能有几个不同状态组合中的一种时。

　　建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

　　意图。

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

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

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

　　意图。

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

　　适用性你想使用一个已经存在的类，而它的接口不符合你的需求。

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

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

　　对象适配器可以适配它的父类接口。

　　意图。

　　将抽象部分与它的实现部分分离，使它们都可以独立地变化。

　　适用性你不希望在抽象和它的实现部分之间有一个固定的绑定关系。

　　例如这种情况可能是因为，在程序运行时刻实现部分应可以被选择或者切换。

　　类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。

　　这时Bridge模式使你可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充。

　　对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。

　　（C ）你想对客户完全隐藏抽象的实现部分。

　　在C 中，类的表示在类接口中是可见的。

　　有许多类要生成。

　　这样一种类层次结构说明你必须将一个对象分解成两个部分。

　　Rumbaugh称这种类层次结构为“嵌套的普化”（nestedgeneralizations）。

　　你想在多个对象间共享实现（可能使用引用计数），但同时要求客户并不知道这一点。

　　一个简单的例子便是Coplien的String类，在这个类中多个对象可以共享同一个字符串表示（StringRep）。

　　意图。

　　将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。

　　适用性你想表示对象的部分—整体层次结构。

　　你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。

　　意图。

　　动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

　　适用性在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。

　　处理那些可以撤消的职责。

　　当不能采用生成子类的方法进行扩充时。

　　一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。

　　另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。

　　意图。

　　为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

　　适用性当你要为一个复杂子系统提供一个简单接口时。

　　子系统往往因为不断演化而变得越来越复杂。

　　大多数模式使用时都会产生更多更小的类。

　　这使得子系统更具可重用性，也更容易对子系统进行定制，但这也给那些不需要定制子系统的用户带来一些使用上的困难。

　　Facade可以提供一个简单的缺省视图，这一视图对大多数用户来说已经足够，而那些需要更多的可定制性的用户可以越过Facade层。

　　客户程序与抽象类的实现部分之间存在着很大的依赖性。

　　引入Facade将这个子系统与客户以及其他的子系统分离，可以提高子系统的独立性和可移植性。

　　当你需要构建一个层次结构的子系统时，使用门面模式定义子系统中每层的入口点。

　　如果子系统之间是相互依赖的，你可以让它们仅通过Facade进行通讯，从而简化了它们之间的依赖关系。

　　意图。

　　运用共享技术有效地支持大量细粒度的对象。

　　适用性一个应用程序使用了大量的对象。

　　完全由于使用大量的对象，造成很大的存储开销。

　　对象的大多数状态都可变为外部状态。

　　如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象。

　　应用程序不依赖于对象标识。

　　由于Flyweight对象可以被共享，对于概念上明显有别的对象，标识测试将返回真值。

　　意图。

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

适用性

　　在需要用比较通用和复杂的对象指针代替简单的指针的时候，使用Proxy模式。

　　下面是一些可以使用Proxy模式常见情况：远程代理（RemoteProxy）为一个对象在不同的地址空间提供局部代表。

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

　　保护代理（ProtectionProxy）控制对原始对象的访问。

　　保护代理用于对象应该有不同的访问权限的时候。

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

　　它的典型用途包括：对指向实际对象的引用计数，这样当该对象没有引用时，可以自动释放它（也称为SmartPointers）。

　　当第一次引用一个持久对象时，将它装入内存。

　　在访问一个实际对象前，检查是否已经锁定了它，以确保其他对象不能改变它。

　　意图。

　　使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

　　适用性有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。

　　你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。

　　可处理一个请求的对象集合应被动态指定。

　　意图。

　　将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可取消的操作

　　适用性像上面讨论的MenuItem对象那样，抽象出待执行的动作以参数化某对象。

　　你可用过程语言中的回调（callback）函数表达这种参数化机制。

　　所谓回调函数是指函数先在某处注册，而它将在稍后某个需要的时候被调用。

　　Command模式是回调机制的一个面向对象的替代品。

　　在不同的时刻指定、排列和执行请求。

　　一个Command对象可以有一个与初始请求无关的生存期。

　　如果一个请求的接收者可用一种与地址空间无关的方式表达，那么就可将负责该请求的命令对象传送给另一个不同的进程并在那儿实现该请求。

　　支持取消操作。

　　Command的Execute操作可在实施操作前将状态存储起来，在取消操作时这个状态用来消除该操作的影响。

　　Command接口必须添加一个Execute操作，该操作取消上一次Execute调用的效果。

　　执行的命令被存储在一个历史列表中。

　　可通过向后和向前遍历这一列表并分别调用Unexecute和Execute来实现重数不限的“取消”和“重做”。

　　支持修改日志，这样当系统崩溃时，这些修改可以被重做一遍。

　　在Command接口中添加装载操作和存储操作，可以用来保持变动的一个一致的修改日志。

　　从崩溃中恢复的过程包括从磁盘中重新读入记录下来的命令并用Execute操作重新执行它们。

　　用构建在原语操作上的高层操作构造一个系统。

　　这样一种结构在支持事务（Transaction）的信息系统中很常见。

　　一个事务封装了对数据的一组变动。

　　Command模式提供了对事务进行建模的方法。

　　Command有一个公共的接口，使得你可以用同一种方式调用所有的事务。

　　同时使用该模式也易于添加新事务以扩展系统。

　　意图。

　　给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

　　适用性当有一个语言需要解释执行,并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。

　　而当存在以下情况时该模式效果最好：该文法简单对于复杂的文法,文法的类层次变得庞大而无法管理。

　　此时语法分析程序生成器这样的工具是更好的选择。

　　它们无需构建抽象语法树即可解释表达式,这样可以节省空间而且还可能节省时间。

　　效率不是一个关键问题最高效的解释器通常不是通过直接解释语法分析树实现的,而是首先将它们转换成另一种形式。

　　例如，正则表达式通常被转换成状态机。

　　但即使在这种情况下,转换器仍可用解释器模式实现,该模式仍是有用的。

　　意图。

　　提供一种方法顺序访问一个聚合对象中各个元素,而又不需暴露该对象的内部表示。

　　适用性访问一个聚合对象的内容而无需暴露它的内部表示。

　　支持对聚合对象的多种遍历。

　　为遍历不同的聚合结构提供一个统一的接口（即,支持多态迭代）。

　　意图。

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

　　适用性一组对象以定义良好但是复杂的方式进行通信。

　　产生的相互依赖关系结构混乱且难以理解。

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

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

　　意图。

　　在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到保存的状态。

　　适用性必须保存一个对象在某一个时刻的(部分)状态,这样以后需要时它才能恢复到先前的状态。

　　如果一个用接口来让其它对象直接得到这些状态，将会暴露对象的实现细节并破坏对象的封装性。

　　意图。

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

　　适用性当一个抽象模型有两个方面,其中一个方面依赖于另一方面。

　　将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。

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

　　当一个对象必须通知其它对象，而它又不能假定其它对象是谁。

　　换言之，你不希望这些对象是紧密耦合的。

　　意图。

　　允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

　　适用性一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为。

　　一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。

　　这个状态通常用一个或多个枚举常量表示。

　　通常,有多个操作包含这一相同的条件结构。

　　State模式将每一个条件分支放入一个独立的类中。

　　这使得你可以根据对象自身的情况将对象的状态作为一个对象，这一对象可以不依赖于其他对象而独立变化。

　　意图。

　　定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

　　适用性许多相关的类仅仅是行为有异。

　　“策略”提供了一种用多个行为中的一个行为来配置一个类的方法。

　　需要使用一个算法的不同变体。

　　例如，你可能会定义一些反映不同的空间/时间权衡的算法。

　　当这些变体实现为一个算法的类层次时，可以使用策略模式。

　　算法使用客户不应该知道的数据。

　　可使用策略模式以避免暴露复杂的、与算法相关的数据结构。

　　一个类定义了多种行为,并且这些行为在这个类的操作中以多个条件语句的形式出现。

　　将相关的条件分支移入它们各自的Strategy类中以代替这些条件语句。

　　意图。

　　定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。TemplateMethod使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

　　适用性一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。

　　各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。

　　这是Opdyke和Johnson所描述过的“重分解以一般化”的一个很好的例子。

　　首先识别现有代码中的不同之处，并且将不同之处分离为新的操作。

　　最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。

　　控制子类扩展。

　　模板方法只在特定点调用“hook”操作，这样就只允许在这些点进行扩展。

　　意图。

　　表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

　　适用性一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。

　　需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而你想避免让这些操作“污染”这些对象的类。

　　Visitor使得你可以将相关的操作集中起来定义在一个类中。

　　当该对象结构被很多应用共享时，用Visitor模式让每个应用仅包含需要用到的操作。

　　定义对象结构的类很少改变，但经常需要在此结构上定义新的操作。

　　改变对象结构类需要重定义对所有访问者的接口，这可能需要很大的代价。

　　如果对象结构类经常改变，那么可能还是在这些类中定义这些操作较好。