行为型模式-状态模式共31页
第6章行为型设计模式
takeNumber(); transact(); evaluate();
Deposit
15:36
Withdraw + transact () : void
Transfer
22
+ transact () : void
+ transact () : void
模板方法模式
模板方法模式实例与解析
实例一：银行业务办理流程
15:36
10
模板方法模式
模式定义
模板方法模式(Template Method Pattern)：定义一 个操作中算法的骨架，而将一些步骤延迟到子类中，模 板方法使得子类可以不改变一个算法的结构即可重定义 该算法的某些特定步骤。模板方法是一种类行为型模式。
15:36
11
模板方法模式
模式定义
15:36
20
模板方法模式
模板方法模式实例与解析
实例一：银行业务办理流程 • 在银行办理业务时，一般都包含几个基本步骤，首先 需要取号排队，然后办理具体业务，最后需要对银行 工作人员进行评分程都一样。现使用模板方法模式模拟 银行业务办理流程。
15:36
14
模板方法模式
模式分析
模板方法模式是一种类的行为型模式，在它的结构图中只 有类之间的继承关系，没有对象关联关系。
在模板方法模式的使用过程中，要求开发抽象类和开发具 体子类的设计师之间进行协作。一个设计师负责给出一个 算法的轮廓和骨架，另一些设计师则负责给出这个算法的 各个逻辑步骤。实现这些具体逻辑步骤的方法称为基本方 法(Primitive Method)，而将这些基本法方法汇总起来 的方法称为模板方法(Template Method)，模板方法模 式的名字从此而来。
软件工程中的状态模式
软件工程中的状态模式作为一种常见的设计模式，状态模式在软件工程领域中被广泛应用。
状态模式是一种行为型模式，它将对象的行为与状态进行了解耦，使得对象在不同的状态下能够执行不同的行为。
本文将对状态模式进行深入的解析，从原理、优点、缺点、实例等方面进行讲解。
一、定义在软件设计中，状态模式是一种行为型模式，它通过封装和分离对象的状态，使其能够在状态发生改变时，能够改变其行为。
在状态模式中，一个对象可以在其内部状态发生改变时改变其行为，而这个状态转换是由开发人员定义的。
二、结构状态模式主要由三个角色组成：Context、State、ConcreteState。
1、Context（上下文）：每个具体状态的实现类都需要与一个Context的类进行交互，Context会在各个状态之间进行转换，同时它本身拥有多个具体状态的实现类，以及一个表示当前状态的成员变量。
2、State（抽象状态）：这个类负责定义角色的行为，以及各个状态之间的转换，在State的实现类中，通常会包括一个与Context交互的方法。
3、ConcreteState（具体状态）：是State的实现类，它通过重写抽象状态中的方法来实现对应状态下的具体行为。
三、原理状态模式的核心思想是将状态与行为进行解耦，这种解耦能够使得系统更加灵活，同时也可以提高代码的可维护性和扩展性。
在状态模式中，对象的行为随着状态变化而变化，这使得对象在不同的状态下表现出不同的行为特点。
四、优点1、良好的扩展性：状态模式可以轻松地扩展新的状态，同时还减少了对象类之间的耦合。
2、避免了大量的条件判断语句：状态模式可以将各个状态之间的转换以及行为的实现进行封装，因此避免了代码中出现大量的条件判断语句。
3、可维护性：状态模式能够将各个状态之间的变化进行封装，因此即使对象发生状态变化，也不会对其他的类产生影响，使得代码更加易于维护。
五、缺点1、增加了类的数量：状态模式虽然可以减少代码中的条件判断语句，但是同时也增加了类的数量。
设计模式分类（创建型模式、结构型模式、行为型模式）
设计模式分类（创建型模式、结构型模式、⾏为型模式）1．创建型模式前⾯讲过，社会化的分⼯越来越细，⾃然在软件设计⽅⾯也是如此，因此对象的创建和对象的使⽤分开也就成为了必然趋势。
因为对象的创建会消耗掉系统的很多资源，所以单独对对象的创建进⾏研究，从⽽能够⾼效地创建对象就是创建型模式要探讨的问题。
这⾥有6个具体的创建型模式可供研究，它们分别是：简单⼯⼚模式（Simple Factory）⼯⼚⽅法模式（Factory Method）抽象⼯⼚模式（Abstract Factory）创建者模式（Builder）原型模式（Prototype）单例模式（Singleton）说明：严格来说，简单⼯⼚模式不是GoF总结出来的23种设计模式之⼀。
2．结构型模式在解决了对象的创建问题之后，对象的组成以及对象之间的依赖关系就成了开发⼈员关注的焦点，因为如何设计对象的结构、继承和依赖关系会影响到后续程序的维护性、代码的健壮性、耦合性等。
对象结构的设计很容易体现出设计⼈员⽔平的⾼低，这⾥有7个具体的结构型模式可供研究，它们分别是：外观模式/门⾯模式（Facade门⾯模式）适配器模式（Adapter）代理模式（Proxy）装饰模式（Decorator）桥梁模式/桥接模式（Bridge）组合模式（Composite）享元模式（Flyweight）3．⾏为型模式在对象的结构和对象的创建问题都解决了之后，就剩下对象的⾏为问题了，如果对象的⾏为设计的好，那么对象的⾏为就会更清晰，它们之间的协作效率就会提⾼，这⾥有11个具体的⾏为型模式可供研究，它们分别是：模板⽅法模式（Template Method）观察者模式（Observer）状态模式（State）策略模式（Strategy）职责链模式（Chain of Responsibility）命令模式（Command）访问者模式（Visitor）调停者模式（Mediator）备忘录模式（Memento）迭代器模式（Iterator）解释器模式（Interpreter）。
GoF的23个经典设计模式
GoF的23个经典设计模式以⽂本和思维导图的⽅式简明扼要的介绍了GoF的23个经典设计模式，可当成学习设计模式的⼀个⼩⼿册，偶尔看⼀下，说不定会对⼤师的思想精髓有新的领悟。
GoF(“四⼈帮”，⼜称Gang of Four，即Erich Gamma, Richard Helm, Ralph Johnson & John Vlissides)创建型模式(5个)：单例模式、原型模式、建造者模式、⼯⼚模式、抽象⼯⼚模式。
结构型模式(7个)：桥接模式、外观模式、组合模式、装饰模式、适配器模式、代理模式、享元模式。
⾏为型模式(11个)：迭代器模式、解释器模式、观察者模式、中介者模式、访问者模式、备忘录模式、状态模式、策略模式、模版⽅法模、命令模式、职责链模式式。
【创建型】Singleton（单例模式）：保证⼀个类仅有⼀个实例，并提供⼀个访问它的全局访问点。
Prototype（原型模式）：⽤原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。
Builder（建造者模式）：将⼀个复杂对象的构建与它的表⽰分离，使得同样的构建过程可以创建不同的表⽰。
Factory Method(⼯⼚模式)：定义⼀个⽤于创建对象的接⼝，让⼦类决定将哪⼀个类实例化。
Factory Method使⼀个类的实例化延迟到其⼦类。
Abstract Factory（抽象⼯⼚模式）：提供⼀个创建⼀系列相关或相互依赖对象的接⼝，⽽⽆需指定它们具体的类。
【结构型】Bridge（桥接模式）：将抽象部分与它的实现部分分离，使它们都可以独⽴地变化。
Facade（外观模式）：为⼦系统中的⼀组接⼝提供⼀个⼀致的界⾯， Facade模式定义了⼀个⾼层接⼝，这个接⼝使得这⼀⼦系统更加容易使⽤。
Composite(组合模式)：将对象组合成树形结构以表⽰“部分-整体”的层次结构。
它使得客户对单个对象和复合对象的使⽤具有⼀致性。
Decorator(装饰模式)：动态地给⼀个对象添加⼀些额外的职责。
设计模式：24个经典模式在实际项目中的应用
设计模式：24个经典模式在实际项目中的应用设计模式是软件开发中一种被广泛采用的行为方案，它们能够解决常见的设计问题，并提供了一种可重用的解决方案。
经典的24个设计模式被认为是软件开发中最常用的模式。
在实际项目中，这些设计模式可以帮助开发人员提高代码的可维护性、复用性和可扩展性。
下面将介绍一些经典的设计模式在实际项目中的应用。
一、创建型模式（Creational Patterns）1.单例模式（Singleton Pattern）单例模式在实际项目中的应用非常广泛。
例如，在一个多线程的应用中，如果有多个线程同时访问同一个对象，可能会导致数据不一致的问题。
使用单例模式可以确保只有一个对象被创建，并提供一个全局访问点，避免了多个对象的创建和同步访问的问题。
2.工厂方法模式（Factory Method Pattern）工厂方法模式在实际项目中常用于对象的创建和实例化。
例如，一个电商平台需要根据用户的需求创建不同的产品对象，在这种情况下，可以使用工厂方法模式来创建和实例化不同的产品对象。
3.抽象工厂模式（Abstract Factory Pattern）抽象工厂模式可以用于创建一组相关或相互依赖的对象。
在实际项目中，例如一个软件需要支持不同的操作系统和数据库，可以使用抽象工厂模式创建适用于不同操作系统和数据库的对象。
二、结构型模式（Structural Patterns）1.适配器模式（Adapter Pattern）适配器模式在实际项目中的应用非常常见。
例如，当一个已存在的接口不符合新的系统要求时，可以使用适配器模式来进行接口转换。
这样既能够重用已有的代码，又能够满足新的系统要求。
2.装饰器模式（Decorator Pattern）装饰器模式在实际项目中常用于给对象动态地增加额外的功能，而不需要修改原有的代码。
例如，在一个图片编辑软件中，可以使用装饰器模式给图片增加滤镜、水印等功能。
3.组合模式（Composite Pattern）组合模式在实际项目中经常用于处理树状结构的数据。
设计模式State_状态模式
State（状态模式）State（状态模式）属于行为型模式。
意图：允许一个对象在其内部状态改变时改变它的行为。
对象看起来似乎修改了它的类。
简单来说，就是将“一个大 class + 一堆if else” 替换为“一堆小class”。
一堆小class 就是一堆状态，用一堆状态代替 if else 会更好拓展与维护。
举例子如果看不懂上面的意图介绍，没有关系，设计模式需要在日常工作里用起来，结合例子可以加深你的理解，下面我准备了三个例子，让你体会什么场景下会用到这种设计模式。
团队接口人团队是由很多同学组成的，但有一位接口人 TL，这位 TL 可能一会儿和产品经理谈需求，一会儿和其他 TL 谈规划，一会儿和 HR 谈人事，总之要做很多事情，很显然一个人是忙不过来的。
TL 通过将任务分发给团队中每个同学，而不让他们直接和产品经理、其他 TL、HR 接触，那么这位 TL 的办事效率就会相当高，因为每个同学只负责一块具体的业务，而 TL 在不同时刻叫上不同的同学，让他们出面解决他们负责的专业领域问题，那么在外面看，这位 TL 团队能力很广，在内看，每个人负责的事情也比较单一。
台灯按钮我们经常会看到只有一个按钮的台灯，但是可以通过按钮调节亮度，大概是如下一个循环“关 -> 弱光 -> 亮 -> 强光 -> 关”，那么每次按按钮后，要跳转到什么状态，其实和当前状态有关。
我们可以用 if else 解决这个问题，也可以用状态模式解决。
用状态模式解决，就是将这四个状态封装为四个类，每个类都执行按下按钮后要跳转到的状态，这样未来新增一种模式，只要改变部分类即可。
数据库连接器在数据库连接前后，这个连接器的状态显然非常不同，我们如果仅用一个类描述数据库连接器，则内部免不了写大量分支语句进行状态判断。
那么此时有更好的方案吗？状态模式告诉我们，可以创建多个不同状态类，比如连接前、连接中、连接后三种状态类，在不同时刻内部会替换为不同的子类，它们都继承同样的父类，所以外面看上去不需要感知内部的状态变化，内部又可以进行状态拆分，进行更好的维护。
行为型设计模式介绍
行为型设计模式介绍行为型设计模式是指用于解决对象之间交互及职责分配的设计模式，它们主要描述了不同对象之间的通信方式，以及如何控制对象之间的交互流程。
这些模式通过将行为分离到不同的对象中，来实现更好的封装性和可复用性。
在本篇论文中，我们将对行为型设计模式做一个简要的介绍，包括模式的定义、分类以及如何在实际开发中应用它们。
一、定义行为型设计模式是指一系列用于对象之间交互和职责分配的设计模式。
这些模式主要解决对象间的通信方式以及如何控制对象之间的交互流程。
与创建型设计模式和结构型设计模式不同，行为型设计模式更关注对象之间的功能分配，而不是组成对象的方式。
行为型设计模式主要包括以下几种：1、责任链模式：将请求的发送者和接收者解耦，构造成一条链，依次发送请求，直到有一个接收者处理为止。
2、命令模式：将请求封装成对象，使得请求的发送者与请求的接收者之间解耦，并且可以动态地添加或删除请求。
3、迭代器模式：提供一种方法来顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
4、中介者模式：定义一个中介对象来封装一系列对象之间的交互，使得各对象之间不需要直接相互作用，从而降低耦合度。
5、备忘录模式：提供一种方式来捕获对象的内部状态，并可以在需要的时候恢复对象到之前的状态。
6、观察者模式：对象之间的一种一对多的依赖关系，当一个对象状态改变时，所有依赖它的对象都会得到通知并且自动更新。
7、状态模式：允许一个对象在其内部状态改变时改变其行为，从而使对象看起来似乎修改了其所属的类。
8、策略模式：定义了一系列算法，并将每个算法都封装起来，使得它们可以互相替换。
9、模板方法模式：定义了一个算法框架，由具体子类实现其中的某些步骤，可以提供一个保护性的具体方法，以约束它的子类必须遵循的规则。
10、访问者模式：在不改变对象的前提下，定义作用于对象某些元素的新操作。
二、分类行为型设计模式可以分为两类：类行为型模式和对象行为型模式。
行为型模式
行为型模式1.简介描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。
行为型模式包括：模板方法模式、策略模式、命令模式、责任链模式、状态模式、观察者模式、中介者模式、迭代器模式、访问者模式、备忘录模式、解释器模式。
2.行为型模式分类(1)模板方法模式说明：将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
优点它封装了不变部分，扩展可变部分。
它把认为是不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。
它在父类中提取了公共的部分代码，便于代码复用。
部分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。
缺点对每个不同的实现都需要定义一个子类，这会导致类的个数增加，系统更加庞大，设计也更加抽象。
父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这导致一种反向的控制结构，它提高了代码阅读的难度。
抽象类源码(2)策略模式说明：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。
抽象策略类源码环境类源码（3）命令模式说明：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。
方便将命令对象进行储存、传递、调用、增加与管理。
优点降低系统的耦合度。
命令模式能将调用操作的对象与实现该操作的对象解耦。
（4）增加或删除命令非常方便。
采用命令模式增加与删除命令不会影响其他类，它满足“开闭原则”，对扩展比较灵活。
可以实现宏命令。
命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令。
方便实现Undo和Redo操作。
命令模式可以与后面介绍的备忘录模式结合，实现命令的撤销与恢复。
缺点：可能产生大量具体命令类。
因为计对每一个具体操作都需要设计一个具体命令类，这将增加系统的复杂性。
24种设计模式及案例
24种设计模式及案例设计模式是软件工程中经过验证的解决其中一类常见问题的可复用设计的描述。
它们提供了一套经过验证的最佳实践，可以帮助开发人员解决各种设计问题，并提高代码的可维护性、重用性和灵活性。
本文将介绍24种常见的设计模式，并为每种模式提供一个案例，以便更好地理解和应用这些设计模式。
1.创建型模式：- 简单工厂模式（Simple Factory Pattern）：通过一个工厂类根据输入参数的不同来创建不同类的对象。
- 工厂方法模式（Factory Method Pattern）：定义一个创建对象的接口，但让子类决定实例化哪一个类。
- 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定具体的类。
- 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供一个全局的访问点来获取该实例。
2.结构型模式：- 适配器模式（Adapter Pattern）：将不兼容的接口转换为可兼容的接口，以便不同类之间可以协同工作。
- 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责，而不需要修改原始类的代码。
- 代理模式（Proxy Pattern）：为其他对象提供一种代理以控制对该对象的访问。
- 外观模式（Facade Pattern）：提供了一个简化接口，用于使用一组复杂子系统的更高级别接口。
3.行为型模式：- 策略模式（Strategy Pattern）：定义一系列算法，将每个算法封装起来，并使它们可以互相替换。
- 观察者模式（Observer Pattern）：定义了对象之间的一对多依赖关系，当一个对象的状态发生变化时，其所有依赖对象都会收到通知并自动更新。
- 模板方法模式（Template Method Pattern）：定义了一个操作的算法框架，而将一些步骤的实现延迟到子类中。
行为型模式-状态模式
Account - state : AccountState - owner : String + Account (String owner, double init) + setState (AccountState state) : void + deposit (double amount) : void + withdraw (double amount) : void ...
•
•
可以让多个环境对象共享一个状态对象，从而减少系 统中对象的个数。
状态模式
模式优缺点
状态模式的缺点
• •
•
状态模式的使用必然会增加系统类和对象的个数。 状态模式的结构与实现都较为复杂，如果使用不当 将导致程序结构和代码的混乱。 状态模式对“开闭原则”的支持并不太好，对于可 以切换状态的状态模式，增加新的状态类需要修改 那些负责状态转换的源代码，否则无法切换到新增 状态；而且修改某个状态类的行为也需修改对应类 的源代码。
状态模式
模式扩展 共享状态
•
在有些情况下多个环境对象需要共享同一个状态，如 果希望在系统中实现多个环境对象实例共享一个或多 个状态对象，那么需要将这些状态对象定义为环境的 静态成员对象。
状态模式
模式扩展 简单状态模式与可切换状态的状态模式
•
(1) 简单状态模式：简单状态模式是指状态都相互独 立，状态之间无须进行转换的状态模式，这是最简单 的一种状态模式。对于这种状态模式，每个状态类都 封装与状态相关的操作，而无须关心状态的切换，可 以在客户端直接实例化状态类，然后将状态对象设置 到环境类中。如果是这种简单的状态模式，它遵循 “开闭原则”，在客户端可以针对抽象状态类进行编 程，而将具体状态类写到配置文件中，同时增加新的 状态类对原有系统也不造成任何影响。
设计模式介绍和分类
设计模式介绍和分类设计模式是面向对象软件设计中的一种经验总结，是解决特定问题的一套优秀的解决方案。
它们提供了一种通用的解决方案，可应用于不同的场景，使软件更加灵活、可维护和可扩展。
设计模式可以根据其目的和使用方式进行分类。
常见的设计模式可以分为创建型模式、结构型模式和行为型模式。
一、创建型模式：1. 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供全局访问点。
2. 工厂模式（Factory Pattern）：定义一个用于创建对象的接口，由子类决定实例化哪个类。
3. 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定具体类。
4. 建造者模式（Builder Pattern）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
5. 原型模式（Prototype Pattern）：通过复制已有对象来创建新对象，避免了使用构造函数的复杂性。
二、结构型模式：1. 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另一个接口。
2. 桥接模式（Bridge Pattern）：将抽象部分与实现部分分离，使它们可以独立变化。
3. 组合模式（Composite Pattern）：将对象组合成树形结构以表示"部分-整体"的层次结构。
4. 装饰器模式（Decorator Pattern）：动态地给一个对象添加额外的职责，同时又不改变其结构。
5. 外观模式（Facade Pattern）：为子系统中的一组接口提供一个统一的接口。
6. 享元模式（Flyweight Pattern）：运用共享技术有效地支持大量细粒度对象的复用。
三、行为型模式：1. 模板方法模式（Template Method Pattern）：定义一个操作中的算法骨架，将一些步骤延迟到子类中实现。
C#设计模式--状态模式
C#设计模式--状态模式设计模式：状态模式（State Pattern）简单介绍：在状态模式（State Pattern）中，类的⾏为是基于它的状态改变的。
这种类型的设计模式属于⾏为型模式。
在状态模式中，我们创建表⽰各种状态的对象和⼀个⾏为随着状态对象改变⽽改变的 context 对象。
酒店房间状态变换图：状态模式类图：上图来源于菜鸟教程⾓⾊：状态模式包含如下⾓⾊：Context: 环境类。
可以包括⼀些内部状态。
State: 抽象状态类。
State定义了⼀个所有具体状态的共同接⼝，任何状态都实现这个相同的接⼝，这样⼀来，状态之间就可以互相转换了。
StartStates/StopState: 具体状态类。
具体状态类，⽤于处理来⾃Context的请求，每⼀个State的具体类都提供了它对⾃⼰请求的实现，所以，当Context改变状态时⾏为也会跟着改变。
酒店房间状态伪类图：状态变迁：然后是3个状态类,这个三个状态分别对于这:空闲、预订、⼊住。
其中空闲可以完成预订和⼊住两个动作，预订可以完成⼊住和退订两个动作，⼊住可以退房。
状态模式C#代码举例状态接⼝1public interface IState2 {3///<summary>4///预定房间5///</summary>6void bookRoom();78///<summary>9///退订房间10///</summary>11void UnSubscribeRoom();1213///<summary>14///⼊住15///</summary>16void CheckInRoom();1718///<summary>19///退房20///</summary>21void CheckOutRoom();2223 }具体的房间类1/*****************************************************2 * ProjectName: _11DesignPattern_StatePattern3 * Description:4 * ClassName: Room5 * CLRVersion: 4.0.30319.184446 * Author: JiYF7 * NameSpace: _11DesignPattern_StatePattern8 * MachineName: JIYONGFEI9 * CreateTime: 2017/7/17 17:31:0010 * UpdatedTime: 2017/7/17 17:31:0011*****************************************************/12using System;13using System.Collections.Generic;14using System.Linq;15using System.Text;1617namespace _11DesignPattern_StatePattern18 {19public class Room20 {21///<summary>22///房间的当前状态23///</summary>24private IState _state;2526public IState State27 {28get { return _state; }29set { _state = value; }30 }31///<summary>32///房间的三个状态33///</summary>34private IState _freeTimeState; //空闲状态3536private IState _checkInState; //⼊住状态3738private IState _bookedState; //预定状态3940///<summary>41///空闲状态的set和get42///</summary>43public IState FreeTimeState44 {45get { return _freeTimeState; }46set { _freeTimeState = value; }47 }4849///<summary>50///⼊住状态的get和set51///</summary>52public IState CheckInState53 {54get { return _checkInState; }55set { _checkInState = value; }56 }5758///<summary>59///预定状态的get和set60///</summary>61public IState BookedState62 {63get { return _bookedState; }64set { _bookedState = value; }65 }66676869public Room()70 {71this._freeTimeState = new FreeTimeState(this); 72this._checkInState = new CheckInState(this); 73this._bookedState = new BookedState(this);74this._state = this._freeTimeState;75 }7677///<summary>78///预定房间79///</summary>80public void bookRoom()81 {82this._state.bookRoom();83 }8485///<summary>86///退订房间87///</summary>88public void UnSubscribeRoom()90this._state.UnSubscribeRoom();91 }9293///<summary>94///⼊住95///</summary>96public void CheckInRoom()97 {98this._state.CheckInRoom();99 }100101///<summary>102///退房103///</summary>104public void CheckOutRoom()105 {106this._state.CheckOutRoom();107 }108109public string getRoomState()110 {111return"该房间的状态是:" + this.State.GetType().ToString();112 }113114115 }116 }三个具体的状态是实现：FreeTimeState.cs 房间空闲状态1/*****************************************************2 * ProjectName: _11DesignPattern_StatePattern3 * Description:4 * ClassName: FreeTimeState5 * CLRVersion: 4.0.30319.184446 * Author: JiYF7 * NameSpace: _11DesignPattern_StatePattern8 * MachineName: JIYONGFEI9 * CreateTime: 2017/7/17 17:34:2810 * UpdatedTime: 2017/7/17 17:34:2811*****************************************************/12using System;13using System.Collections.Generic;14using System.Linq;15using System.Text;1617namespace _11DesignPattern_StatePattern18 {19public class FreeTimeState:IState20 {21private Room _hotelManagement;22public FreeTimeState()23 { }2425public FreeTimeState(Room hotelManagement)26 {27this._hotelManagement = hotelManagement;28 }29public void bookRoom()30 {31//设置状态为已经预定状态32this._hotelManagement.State = this._hotelManagement.BookedState;33 Console.WriteLine("您已经成功预定了...");34 }3536public void UnSubscribeRoom()37 {38//暂不操作39 }4041public void CheckInRoom()42 {43this._hotelManagement.State = this._hotelManagement.CheckInState;44 Console.WriteLine("您已经成功⼊住...");45 }4647public void CheckOutRoom()48 {49//暂不操作52 }BookedState.cs房间预订状态1/*****************************************************2 * ProjectName: _11DesignPattern_StatePattern3 * Description:4 * ClassName: BookedState5 * CLRVersion: 4.0.30319.184446 * Author: JiYF7 * NameSpace: _11DesignPattern_StatePattern8 * MachineName: JIYONGFEI9 * CreateTime: 2017/7/17 17:34:4510 * UpdatedTime: 2017/7/17 17:34:4511*****************************************************/12using System;13using System.Collections.Generic;14using System.Linq;15using System.Text;1617namespace _11DesignPattern_StatePattern18 {19public class BookedState:IState20 {21private Room _hotelManagement;22public BookedState()23 { }2425public BookedState(Room hotelManagement)26 {27this._hotelManagement = hotelManagement;28 }29public void bookRoom()30 {31 Console.WriteLine("该房间已经预定了...");32 }3334public void UnSubscribeRoom()35 {36this._hotelManagement.State = this._hotelManagement.FreeTimeState;37 Console.WriteLine("退订成功,欢迎下次光临...。
23种设计模式总结
23种设计模式总结设计模式是一种解决反复出现的设计问题的方案，它们被广泛应用于软件设计和架构中。
在这里，我们列举了23种常用的设计模式，分别属于创建型、结构型和行为型模式。
一、创建型模式1. 工厂方法模式（Factory Method Pattern）定义一个创建对象的接口，但让子类决定实例化哪个类。
工厂方法模式是让类来进行对象的创建，而不是由你的代码直接new 出来。
2. 抽象工厂模式（Abstract Factory Pattern）提供一个接口，用于创建一系列相关或相互依赖的对象。
3. 单例模式（Singleton Pattern）确保一个类只有一个实例，并提供一个全局访问点。
4. 建造者模式（Builder Pattern）将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
5. 原型模式（Prototype Pattern）用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。
二、结构型模式6. 适配器模式（Adapter Pattern）将一个类的接口转换成客户希望的另外一个接口。
适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。
7. 桥接模式（Bridge Pattern）将抽象部分与它的实现部分分离，使它们都可以独立地变化。
8. 组合模式（Composite Pattern）将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。
9. 装饰器模式（Decorator Pattern）动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器比生成子类更为灵活。
10. 外观模式（Facade Pattern）为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，使得这一子系统更加容易使用。
11. 享元模式（Flyweight Pattern）运用共享技术有效地支持大量细粒度的对象。
行为型模式
涉及到算法和对象间职责的分配。 行为模式不经描述对象或类的模式， 还描述它们之间的通讯模式。这些对象间的联系方式上来。
1， 观察者模式（Observer）； 2， 模板方法（TemplateMethod）； 3， 命令模式（Command）； 4， 状态模式（State）； 5， 职责链模式（Chain of Responsibility）。
观察者模式
定义了对象间的一种一对多的依赖关系，让多个观察者 同时监听某一个主题对象。当一个对象的状态发生变化时， 所有依赖与它的对象都得到通知并被自动更新。 观察者模式所做的工作其实就是在解除耦合。让耦合的 双方都依赖于抽象，而不是依赖于具体。从而使得各自的变 化都不会影响另一边的变化。 事件委托：就是一种引用方法的类型。一旦为委托分配 了方法，委托将于该方法具有完全相同的行为。委托方法的 使用可以想其他任何方法一样，具有参数和返回值。委托可 以看做是对函数的抽象，是函数的‘类’，委托的实例将代 表一个具体的函数。 一个委托可以搭载多个方法，所有方法被依次换起。它 可以使得委托对象所搭载的方法不需要属于同一个类。
设计模式之行为型模式一
软件英才网软件行业驰名招聘网站设计模式之行为型模式一来自何静媛的博客行为型模式：观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象.这个主题对象在状态发生变化时,会通知所有观察者对象,使它们能够自动更新自己.观察者模式的关键对象是主题Subject和观察者Observer，一个Subject可以有任意数目的依赖它的Observer，一旦Subject的状态发生了变化，所有的Observer都可以得到通知。
Subject发出通知时并不需要知道谁是它的观察者，也就是说，具体观察者是谁，它根本不需要知道。
而任何一个具体观察者不知道也不需要知道其他观察者的存在。
应用：1，当一个对象的改变需要同时改变其他对象的时候，而且它不知道具体有多少对象有待改变时。
软件英才网软件行业驰名招聘网站2，一个抽象模型有两个方面，其中一方面依赖于另一方面。
观察者模式所做的工作就是在解耦合。
让耦合的双方都依赖于抽象，而不是依赖于具体。
从而使得各自的变化都不会影响另一边的变化。
课本实例：前台帮同事观察老板的情况代码如下：[csharp]view plaincopyprint?1.//通知者接口2.//一般用一个抽象类或者一个接口实现.它把所有对观察者对象的引用保存在一个聚集里,每个主题都可以有任何数量的观察者.抽象主题提供一个接口,可以增加和删除观察者对象3.interface subject4. {5.void attach(Observer observer);6.void detch(Observer observer);7.void notify();8.string subjectstate9. {10.get;11.set;12. }13. }14.//将有关状态存入具体观察者对象，在具体主题的内部状态改变时，给所有登记过的观察者发出通知15.class boss : subject16. {17.//同事列表18.private IList <Observer>observers=new List <Observer>();19.private string action;20.//增加21.public void attach(Observer observer)22. {23. observers.Add(observer);软件英才网软件行业驰名招聘网站24.25. }26.//减少27.public void detach(Observer observer)28. {29. observers.Remove(observer);30.31. }32.//通知33.public void Notify()34. {35.foreach (Observer o in observers)36. o.update();37.38. }39.//老板状态40.public string subjectstate41. {42.get {return action;}43.set {action=value;}44. }45.46. }47.//抽象观察者48.//为所有观察者定义一个接口,在得到主题通知时更新自己.49.abstract class Observer50. {51.protected string name;52.protected subject sub;53.54.public Observer(string name, subject sub)55. { = name;57.this.sub = sub;58.59. }60.public abstract void update();61.62. }63.//看股票的同事64.//实现抽象观察者角色所要求的更新接口65.class stockobserver : Observer66. {软件英才网软件行业驰名招聘网站67.public stockobserver(string name, subject sub)68. : base(name, sub)69.70. { }71.public override void update()72. {73. Console.WriteLine("{0}{1}关闭股票行情，继续工作", sub.subjectstate, name);74.75. }76. }77.个人理解观察者模式不足：对于已经封装好的类来说，即使他们对某一变化产生动作，但产生这一动作的方法名称也不一定一样，如果我用观察者模式的话，当我定义抽象观察者时，是很麻烦的，需要改动已经封装好的类的名称等内容。