Mediator模式
设计模式-调停者
实践的一小步 代码质量的一大步
模式时序图
: Colleague1 : ConcreteMe... : Colleague2
1: change( ) 2: colleagueChanged( ) 3: action( ) 4: action( )
实践的一小步 代码质量的一大步
模式分析
● 优点
● 可以减少使用静态的继承关系，是的具体同事类可以更加容易得被复用 ● 可以避免同事对象之间的过度耦合，使得调停者类与同事类可以相对独 立的演化 ● 将多对多的相互作用转换为一对多的相互作用，是的对象之间的关系更 加易于维护和理解 ● 将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相 互作用分开
● 实现了抽象调停者所声明的事件方法。具体调停者知晓所有的同 事对象，并从具体同事对象接受消息，向具体同事对象发出命令
● 抽象同事(Colleague)角色：
● 定义出调停者到同事对象的接口。同事对象只知道调停者，而不 知道其余的同事对象
● 具体同事(Concrete Colleague)角色
● 每一个具体同事类都清楚自己在小范围内的行为，而不知道它在 大范围内的目的。
设计模式
—调停者模式
实践的一小步 代码质量的一大步
调停者模式（Mediator Pattern）
● 是对象的行为模式。
● 包装了一系列对象相互作用的方式，是这些对象不 必相互明显引用，从而使他们可以较松散的耦合， 使得其可以彼此独立的变化。 ● 增加协作性(Collaboration),减少耦合度(Coupling) ● 体现了“迪米特法则（LoD）（最少知识原则）” ● 属于很容易被滥用的一个设计模式
实践的一小步 代码质量的一大步
设计模式主要分三个类型
设计模式主要分三个类型:创建型、结构型和行为型。
其中创建型有：一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。
三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。
四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。
五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。
行为型有：六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。
七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。
八、Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。
九、Command，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。
十、State，状态模式：允许对象在其内部状态改变时改变他的行为。
对象看起来似乎改变了他的类。
十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以独立于使用它们的客户。
十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系十三、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。
一、调停者模式
⼀、调停者模式调停者模式（Mediator）模型图主要思想实际编写业务代码时，可能会涉及很多对象，⽐如说A需要B和C，B⼜需要C和A,对象数量多且关系复杂，这时候想要A，B，C都解耦出来，也就是说 A不持有B和C的引⽤，B也不持有A和C的引⽤，这时候就可以采⽤调停者模式了。
新建⼀个Meditor对象，让它协调各个对象之间关系，代码上，Meditor 可以持有A，B，C，D的引⽤，A需要B做事的时候，就可以调⽤Meditor的⽅法，这样就解耦了。
⽰例代码/*** 抽象调停者类*/interface Mediator {void notify (Colleague colleague);}/*** 抽象同事类*/abstract class Colleague {/* 持有调停者对象 */private Mediator mediator;public Colleague(Mediator mediator){this.mediator = mediator;}public Mediator getMediator(){return mediator;}}/*** 具体调停者类*/class ConcreteMediator implements Mediator{private ConcreteColleagueA colleagueA ;private ConcreteColleagueB colleagueB ;public void setColleagueA(ConcreteColleagueA colleagueA) {this.colleagueA = colleagueA;}public void setColleagueB(ConcreteColleagueB colleagueB) {this.colleagueB = colleagueB;}@Overridepublic void notify(Colleague colleague) {System.out.println("协调通知消息");}}/*** 具体同事类*/class ConcreteColleagueA extends Colleague{public ConcreteColleagueA(Mediator mediator) {super(mediator);}public void operate(){getMediator().notify(this);}}class ConcreteColleagueB extends Colleague{public ConcreteColleagueB(Mediator mediator) {super(mediator);}public void operation(){getMediator().notify(this);}}实际场景类似MQ的⽤法，使得各个组件互相解耦。
23种设计模式记忆口诀
23种设计模式记忆口诀设计模式是软件开发中常见的解决方案模板，它们能够解决许多常见的设计问题。
为了帮助记忆23种设计模式，可以使用下面这个口诀来记忆：Creational Patterns（创建型模式）:1. Singleton（单例模式）：一个类能产生一个实例，全局访问。
2. Builder（建造者模式）：分步骤创建复杂对象，易拓展。
3. Factory Method（工厂方法模式）：子类决定实例化哪个对象。
4. Abstract Factory（抽象工厂模式）：创建一组相关对象，不依赖具体类。
5. Prototype（原型模式）：通过复制现有对象来创建新对象。
Structural Patterns（结构型模式）:6. Adapter（适配器模式）：将类的接口转换为客户端希望的接口。
7. Bridge（桥接模式）：将抽象部分与实际部分分离。
将对象组合成树形结构来表示部分整体的层次结构。
9. Decorator（装饰器模式）：动态地给对象添加功能。
10. Facade（外观模式）：提供一个统一的接口，简化客户端使用。
11. Flyweight（享元模式）：共享细粒度对象，减少内存使用。
12. Proxy（代理模式）：控制对其他对象的访问。
Behavioral Patterns（行为型模式）:13. Chain Of Responsibility（责任链模式）：将请求的发送者和接收者解耦，多个对象都可能处理请求。
将请求封装成对象，可以用参数化方式处理。
15. Iterator（迭代器模式）：提供一种遍历集合的统一接口。
16. Mediator（中介者模式）：将多个对象之间的复杂关系解耦。
17. Memento（备忘录模式）：将对象的状态保存起来，以后可以恢复。
18. Observer（观察者模式）：当一个对象改变状态时，依赖它的对象都会收到通知。
19. State（状态模式）：对象的行为随状态的改变而改变。
软件工程案例分析题
案例分析：1、某公司为了降低工资总金额，决定减少全职员工，在业务需要时，从劳动力资源公司临时聘用技术人员，这些人员的考勤信息必须反馈给劳动力资源公司以便计算聘用费用。
小张和小王是公司的软件技术人员，他们发现公司现有的人事管理系统，员工对象的设计和劳动力资源公司的设计不一样，无法直接更新他们的数据库。
为了减少已有软件的改动，小张对小王说，采用适配器模式修改我们的管理系统吧。
小王考虑了一下，说完全正确。
请简要介绍一下适配器设计模式和在此带来的益处。
(150字以内) P223要点：适配器（Adapter）模式将一个类的接口转换成为客户期望的另一种接口，使得原本因接口不匹配而无法合作的类可以一起工作。
使用Adapter模式，在两种接口之间创建一个混合接口。
适配器模式有类适配器模式和对象适配器模式。
类适配器可以通过多继承方式实现不同接口之间的相容和转换，而一个对象适配器则依赖对象组合的技术实现接口的相容和转换。
益处是使得原本因接口不匹配而无法合作的类可以一起工作。
2、小张和小王在为公司做供销存管理系统，发现采购、销售、库存管理相互关联强烈，如下达采购任务，要考虑该产品的销售业绩和目前的库存状态；为了减少各个对象的耦合，小张决定采用中介者模式设计各个子系统。
小王考虑了一下，说完全可以，当以后财务系统也介入的时候，系统的维护升级也比较省事。
请简要介绍一下中介者设计模式和它的优点。
(150字以内)。
P226 要点：中介者（Mediator）模式用一个中介对象来封装一系列复杂对象的交互情景。
中介者通过阻止各个对象之间的相互引用来降低它们之间的耦合，使得人们可以独立的改变他们之间的交互。
中介者负责居中指挥协调一组对象之间的交互行为，避免相互直接引用。
这些对象只认得中介者，因而可以降低交互行为的数目。
优点是降低对象之间的耦合，使得人们可以独立的改变他们之间的交互。
3、某物业管理公司，业务壮大了，在城市很多小区都开展业务。
24种设计模式
24种设计模式Factory Pattern(⼯⼚模式)：1. 创建对象的接⼝，封装对象的创建；2. 使具体化类的⼯作延迟到⼦类中。
（维护⼀类对象）AbstractFactory Pattern(抽象⼯⼚模型)：该模式将⼀组对象的创建封装到⼀个⽤于创建对象的类中。
（解决的问题：要创建⼀组或者相互依赖的对象）。
Singleton Pattern(单例模式)：该模式在⾯向纯粹的⾯向对象的范式中⽤于创建唯⼀的实例，值得注意的是Singleton不能被实例化，因此将其构造函数声明为protected或private类型。
Singleton Pattern经常与Factory Pattern结合使⽤，因为Factory对象只能有⼀个。
Builder Pattern(创建者模式)：将⼀个复杂的对象的构建与它的表⽰分离，使得同样的构建构成可以创建不同的表⽰。
如建筑师画图纸，⽽⼯⼈建造房屋。
Prototype Pattern(原型模式)：提供⼀个通过已存在对象进⾏新对象创建的接⼝（clone）。
（浅拷贝和深拷贝）Bridge Pattern(桥梁模式)：将抽象部分与实现部分分开实现，使他们都可以独⽴地变化，并使⽤组合的⽅式将多维度的抽象⽅法联系在⼀起。
⽐如咖啡分⼩杯、中杯、⼤杯以及加奶和不加奶，则抽象部分为：⼩杯、中杯、⼤杯，⾏为为：加奶和不加奶。
Adapter Pattern(适配器模式)：适配就是由“源”到“⽬标”的适配，⽽当中链接两者的关系就是适配器。
它负责把“源”过度到“⽬标”。
将⼀个类的接⼝转换成客户希望的另外⼀个接⼝。
Adapter模式使得原本由于接⼝不兼容⽽不能⼀起⼯作的那些类可以⼀起⼯作。
适配器模式分为两种：①⾯向类的设计模式；②⾯向对象的设计模式。
①⾯向类的适配器：该模式使⽤继承和接⼝实现的⽅式复⽤需要适配器的类。
②⾯向对象的适配器：该模式使⽤组合的⽅式实现需要复⽤的类。
Decorator模式（装饰模式）：动态地给⼀个对象添加⼀些额外的职责。
调停者模式(Mediator Pattern)
通常，面向对象应用程序是由一组为了提供某种服务而彼此交互的对象组成。
当彼此引用的对象数量比较少时，此时对象之间就为直接交互（点对点）。
图31.1展示了当ObjectA和ObjectB之间彼此直接引用时的直接交互。
Figure 31.1: Point-to-Point Communication in the Case of Two Objects 当对象的数量增加时，这种直接交互会导致对象之间复杂的、混乱的引用（如图31.2）。
这就会影响应用程序的可维护性。
同时，因为对象之间的高耦合，当一个对象直接引用其他的对象时，缩小了这些对象的复用范围。
Figure 31.2: Point-toPoint Communication?Increased Number of Objects 在这种情况下，调停模式（Mediator Pattern）可以为这组对象设计一个控制、协调交互（交流）的模型，从而消除对象直接引用其他对象的需求。
（如图31.3）Figure 31.3: Object Interaction?Mediator as a Communication Hub 调停者模式（Mediator Pattern）推荐抽象所有对象交互的细节到一个独立的类，这个类就是调停者，它负责这组对象之间的交互。
这组对象中的每一个对象仍然负责提供它所具有的服务，但为了提供服务，对象之间不能直接彼此交互。
两个不同对象之间的交互通过调停者（Mediator）进行路由。
所有的对象把消息发送给调停者（Mediator）。
调停者（Mediator）依据应用程序的需求把消息再发送给相应的对象。
这样的设计有以下主要的优点：（1）随着所有对象的交互行为移到一个独立的对象中，通过调停者（Mediator）的子类替换调停者（Mediator）或者改变它的功能可以很容易的改变对象之间内部的关联行为。
（2）将对象的内部依赖关系移到一个单独的对象，这样会提高对象的可用（3）因为对象不需要直接引用其他的对象，所以对象可以更容易的进行单元测试。
分享一下我记忆23种设计模式的方法
分享⼀下我记忆23种设计模式的⽅法来CNBLOGS好久了，也没写过点什么，最近在学习23种设计模式，既然是要学习这些模式，⾸先得记住吧，呵呵，下⾯我总结我⼀下我的记忆⽅法，希望给⼤家分享。
⾸先列出23种设计模式1 Singleton 单件2 Abstract Factory 抽象⼯⼚模式3 Builder ⽣成器模式4 Factory Method ⼯⼚⽅法模式5 Prototype 原型模式6 Adapter 适配器模式7 Bridge 桥接模式8 Composite 组合模式9 Decorator 装饰模式10 Facade 外观模式11 Flyweight 享元模式12 Proxy 代理模式13 Template Methed模板⽅法14 Command 命令模式15 Interpreter 解释器模式16 Mediator 中介者模式17 Iterator 迭代器模式18 Observer 观察者模式19 Chain Of Responsibility 职责链模式20 Memento 备忘录模式21 State 状态模式22 Strategy 策略模式23 Visitor 访问者模式下⾯我们开始这样记忆根据设计模式前的数字来联想记忆，把1，11，21这样的模式串联起来记忆。
具体如下：1------ 肯定是⼀个了，所以是单个，联想单件模式；11----- 1是最⼩单位，11是由两个1(可以想象成多个1)组成，要解决多个1共享资源的模式是享元模式21----- 由2变成了1.可以想象成⼩弟弟见到MM后由S形变成了棍形，状态发⽣了变化 ---状态模式2------ 把2想象成鸭⼦，是我们的想象，是我们的抽象，想到抽象⼯⼚模式12----- 把我们1家的产品叫给2家或更多家来代理，想到代理模式22----- 从家到公司有2条（或多条）路来⾛（把每个2都想象成弯弯的路），⾛每条都是⼀个策略，策略模式3------ 想象成MM的胸部，⽣成奶汁的地⽅，⽣成器模式13-----⽤印模印过⼩猪吧，这个想象到什么了吗？对！把这个样⼦⾥填充⼀些泥巴，就可以得到MM的mimi模型喽，13象个模板吧？呵呵模板⽅法23-----这个更简单了，两只⼿来摸（访问）MM的mimi，访问者模式4------- 4象⼀⾯⼩红旗，象⼀⾯插在⼯⼚屋顶的⼩红旗，⼯⼚⽅法模式14------ 4象⼀⾯⼩红旗，1⾯红旗就是⼀道命令，命令模式5------- 5象个挺着⼤肚⼦的孕妇，穿再多的⾐服也掩盖不了她这种原型，原型模式15------ 旁边已经有1个⼩孩了，你怎么⼜怀上了？给⼤家解释⼀下吧，解释器模式6-------带天线的电⼦器件，适配器？适配器模式16------我要在淘宝上买⼀个适配器，淘宝就是中介者，中介者模式7-------想象成天桥，桥接模式17------⼀座桥连⼀座桥，桥上还有桥，迭代器模式8------- 8是由oo组合⽽成的组合模式18------- 带着1个望远镜（8象⼀个望远镜）⼲吗？观察呗！观察者模式9------- 象⼀个⽓球，⽓球是⽤来装饰的，装饰模式19------- ⼀串⽓球，每个⽓球都有⾃⼰的位置和职责，职责链模式10------- 瞧，⼀个鸡蛋，鸡蛋的外观就是这样的，外观模式20-------⼀个台灯，⼀个圆桌，我在写备忘录，备忘录模式好了，写到这吧，先每个⼈都有⾃⼰的记忆⽅法，我就是联想，就是瞎想，世界没有联想将会怎样？（另，今天11:10~11:30左右，由于同时链接过多造成⽹站不能访问，当我发布的时候，⽹站不能访问了，苦呀，哭呀，还好，我⼜写了⼀遍）。
软件设计模式三大类
软件设计模式三⼤类创建型⼯⼚模式与抽象⼯⼚模式（Factory Pattern）（Abstract Factory Pattern）单例模式（Singleton Pattern）建造者模式（Builder Pattern）原型模式（Prototype Pattern）1、⼯⼚⽅法模式⼯⼚⽅法模式的创建是因为简单⼯⼚模式有⼀个问题，在简单⼯⼚模式中类的创建依赖⼯⼚类，如果想要拓展程序，必须对⼯⼚类进⾏修改，这违背了开闭原则，所以就出现了⼯⼚⽅法模式，只需要创建⼀个⼯⼚接⼝和多个⼯⼚实现类。
⼦类可以⾃⼰决定实例化哪⼀个⼯⼚类，client类针对抽象接⼝进⾏编程，如果需要增加新的功能，继承⼯⼚接⼝，直接增加新的⼯⼚类就可以了，创建过程延迟到⼦类中进⾏，不需要修改之前的代码，满⾜了开闭原则，达到灵活地⽣产多种对象。
2、抽象⼯⼚模式抽象⼯⼚模式是提供⼀个创建⼀系列相关或相互依赖对象的接⼝，⽽⽆需指定它们具体的类。
区别于⼯⼚⽅法模式的地⽅，⼯⼚⽅法模式是创建⼀个⼯⼚，可以实现多种对象；⽽抽象⼯⼚模式是提供⼀个抽象⼯⼚接⼝，⾥⾯定义多种⼯⼚，每个⼯⼚可以⽣产多种对象。
前者的重点在于"怎么⽣产"，后者的重点在于"⽣产哪些"；前者是⼀个抽象产品类，可以派⽣出多个具体产品类，后者是多个抽象产品类，每个抽象产品类可以派⽣出多个具体产品类。
3、单例模式单例模式能保证⼀个类仅有⼀个实例，并提供⼀个访问它的全局访问点，同时在类内部创造单⼀对象，通过设置权限，使类外部⽆法再创造对象。
单例对象能保证在⼀个JVM中，该对象只有⼀个实例存在。
在创建的时候，省去了new操作符，降低了系统内存的使⽤频率，减轻了系统的压⼒。
同时单例模式保证在⼀个jvm中仅存在⼀个实例的好处就在于好⽐⼀个军队当中只会存在⼀个最⾼级别的军官来指挥整个军队，这样才能保证独⽴控制整个过程，否则如果出现多个，肯定会杂乱⽆序。
23种设计模式的经典运用
23种设计模式的经典运用介绍设计模式是解决软件设计中常见问题的可重复使用的解决方案。
本文将介绍23种经典的设计模式，并给出它们在实际开发中的应用示例。
通过学习这些设计模式，您将增加对软件设计的理解，并能够更好地解决问题。
创建型设计模式1.工厂方法模式（F a c t o r y M e t h o d）工厂方法模式通过定义一个创建对象的接口，但由子类决定实例化具体类。
这种方法可以延迟实例化过程，具有更高的灵活性和可扩展性。
应用场景：-在一个系统中，希望客户端与具体类的实例化解耦。
-希望通过增加具体类的扩展来增加系统的灵活性。
2.抽象工厂模式（A b s t r a c t F a c t o r y）抽象工厂模式提供一个接口，用于创建相关或依赖对象组。
这种模式将对象的实例化推迟到子类中，从而实现了解耦。
应用场景：-当一个系统独立于其产品的创建、组合和表示时。
-当需要一个系列的相互依赖的对象而无需指定其具体类时。
3.单例模式（S i n gl e t o n）单例模式确保一个类只有一个实例，并提供一个全局访问点。
这种模式常用于控制对资源的访问，例如数据库连接或日志文件。
应用场景：-当需要一个类的唯一实例，并且该实例需要被多个客户端共享时。
-当需要限制系统中特定类的实例数量时。
4.原型模式（P r o to t y p e）原型模式通过复制现有对象来创建新对象。
这种模式对于创建需要消耗大量资源的对象非常有用，可以通过克隆现有对象来提高性能。
应用场景：-当一个系统的某些对象的创建比较昂贵时。
-当需要避免构造函数调用，而直接通过复制现有对象来创建新对象时。
5.建造者模式（B ui l d e r）建造者模式将一个复杂对象的构建过程与其表现分离，使得相同的构建过程可以创建不同的表现。
应用场景：-当想要构建一些复杂对象时，如生成器。
-当需要创建对象的过程具有多个步骤，并且每个步骤都可以按需选择或省略时。
结构型设计模式6.适配器模式（A da p t e r）适配器模式将一个类的接口转换为客户端所期望的另一个接口。
24种设计模式的定义和使用场合
一.创建型模式(Creational):简单工厂模式(simpleFactory)发音:['simpl] ['fækt(ə)rɪ]定义:提供一个创建对象实例的功能,而无须关心其具体实现.被创建实例的类型可以是接口,抽象类,也可以是具体的类.1.抽象工厂(AbstractFactory)发音: ['æbstrækt]定义:提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类.使用场合:1.如果希望一个系统独立于它的产品的创建,组合和表示的时候,换句话书,希望一个系统只是知道产品的接口,而不关心实现的时候.2.如果一个系统要由多个产品系列中的一个来配置的时候.换句话说,就是可以,就是可以动态地切换产品簇的时候.3.如果强调一系列相关产品的接口,以便联合使用他们的时候2.建造者模式(Builder)发音: ['bɪldə]定义:将复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示.使用场合:1.如果创建对象的算法,应该独立于该对象的组成部分以及它们的装配方式时2.如果同一个构建过程有着不同的表示时3.工厂方法模式(Factory Method)定义:为创建对象定义一个接口,让子类决定实例化哪个类.工厂方法让一个类的实例化延迟到了子类.使用场景:1.客户类不关心使用哪个具体类,只关心该接口所提供的功能.2.创建过程比较复杂,例如需要初始化其他关联的资源类,读取配置文件等.3.接口有很多具体实现或者抽象类有很多具体子类时,4.不希望给客户程序暴露过多的此类的内部结构,隐藏这些细节可以降低耦合度.5.优化性能,比如缓存大对象或者初始化比较耗时的对象.4.原型模式(Prototype Method)发音: ['prəʊtətaɪp]定义:使用原形实例指定将要创建的对象类型,通过复制这个实例创建新的对象.应用场合:1.如果一个系统想要独立于它想要使用的对象时,可以使用原型模式,让系统只面向接口编程,在系统需要新的对象的时候,可以通过克隆原型来得到.2.如果需要实例化的类是在运行时刻动态指定时,可以使用原型模式,通过克隆原型来得到需要的实例.5.单例模式(Singleton) 发音: ['sɪŋg(ə)lt(ə)n]定义:保证一个类仅有一个实例,并提供一个访问它的全局访问点.使用场合:当需要控制一个类的实例只能有一个,而且客户只能从一个全局访问点访问它时,可以使用单例模式,这些功能恰好是单例模式要解决的问题.二.结构型模式(struct)发音: [strʌkt]6.适配器模式(Adapter)发音:[ə'dæptə]定义:将一个类的接口转换成客户希望的另外一个接口.适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作.使用场合;1.如果先要使用一个已经存在的类,但是它的接口不符合你的需求,这种情况可以使用适配器模式,来把已有的实现转换成你需要的接口.2.如果你想创建一个可以复用的类,这个类可能和一些不兼容的类一起工作,这中情况可以使用适配器模式,到时候需要什么就适配什么.3.如果你想使用一些已经窜在的子类,是不坑对每一个子类都进行适配,这中情况可以使用适配器模式,直接适配这些子类的父类就可以了.7.桥接模式(Bridge)发音: [brɪdʒ]定义:将抽象部分与它的实现部分分离,使他们可以独立变化.使用场合:1.如果你不希望在抽象部分和实现部分采用固定的绑定关系,可以采用桥接模式.2.如果出现抽象部分和实现部分都能够扩展的情况,可以采用桥接模式,让抽象部分和实现部分独立地变化.3.如果希望实现部分的修改不会对客户产生影响,可以采用桥接模式.4.如果采用继承的实现方案,会导致产生很多子类,对于这种情况,可以考虑采用桥接模式.8.组合模式(Composite)发音: ['kɒmpəzɪt]定义:将对象组合成属性结构以表示"部分-整体"的层次结构,组合模式使用的用户对单个对象和组合对象的使用具有一致性.使用场合:1.如果你想表示对象的部分-整体层次结构,可以使用..把整体和部分的操作统一起来,使得层次结构实现更简单,从外部来使用,这个层次结构也容易.2.如果希望同意地使用组合结构中的所有对象,可以选用...,这正是组合模式提供的主要功能.9.装饰器模式(Decorator Method)发音: ['dekəreɪtə]定义:动态的给一个对象增加一些额外的职责,就增加功能来说,装饰模式生成子类更为灵活.使用场合:1.如果需要爱不影响其他对象的情况下,以动态,透明的方式给对象添加职责,可以使用装饰模式.2.如果不适合使用子类来进行扩展的时候,可以考虑使用装饰模式.10.外观模式(Facade)发音: [fə'sɑ:d]定义:为子系统中的一组接口提供一个一致的界面,Facade模式定义了一个高层的接口,这个接口使得这一子系统更加同容易使用.使用场景:1.如果希望为一个复杂的子系统提供一个简单接口的时候,可以考虑使用外观模式.使用外观对象来实现大部分客户需要的功能,从而简化客户的使用.2.如果想要让客户程序和抽象类的实现部分松散耦合,可以考虑使用外观模式,使用外观对象来将这个子系统与他的客户分离开来,从而提高子系统的独立性和可移植性.3.如果构建多层节后的系统,可以考虑使用外观模式使用外观模式对象作为每层的入口,这样可以简化层间调用,也可以松散出层次之间的依赖关系.11.享元模式(Flyweight)发音: ['flaɪweɪt]定义:运用共享技术有效地支持大量细粒度的对象.使用场合:1.如果一个应用程序使用了大量的细粒度对象,可以使用享元模式来减少对象的数量.2.如果犹豫使用大量的对象,造成很大的存储开销,可以使用享元模式来减少对象数量,并节约内存.3.如果对象的大多数状态都可以转变成外部状态,比如通过计算得到,或者从外部传入等,可以使用享元模式来实现内部状态和外部状态的分离.4.如果不考虑对象的外部状态,可以用相对较少的共享对象取代很多组合对象,可以使用享元模式来共享对象.然后组合对象来使用这些共享对象.12.代理模式(Proxy)发音: ['prɒksɪ]定义:为其他对象提供一种代理以控制对这个对象的访问.使用场合:1.需要为一个对象在不同的地址空间提供局部代表的时候,可以使用远程代理.2.需要按照需要创建开销很大的对象的时候,可以使用虚代理.3.需要控制对原始对象的访问的时候,可以使用保护代理.4.需要在访问你对象执行一些附加操作的时候,可以使用智能指引代理.三.行为型模式(behavioral)发音[bi'heivjərəl]13.职责链模式(Chain Of Responsibility)发音: [tʃeɪn] [rɪ,spɒnsɪ'bɪlɪtɪ]定义:使多个对象都有机会处理请求,,从而避免请求的发送者和接收者之间耦合关系.将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止.使用场合:1.如果有多个对象可以处理同一个请求,但是具体由哪个对象来处理该请求,是运行时刻动态确定的.2.如果你想在不明确指定接收者的情况下,向多个对象中的其中一个提交请求的话,可以使用职责链模式.3.如果想要动态指定处理一个请求的对象结合,可以使用职责链模式.14.命令模式(Command)发音: [kə'mɑːnd]定义:将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化,对请求排队或者记录请求日志,以及支持可撤销的操作.15.解释器模式(Interpreter)发音: [ɪn'tɜːprɪtə]定义:给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子.使用场合:16.迭代器模式(Iterator)定义:提供一种方法顺序访问一个聚合对象中的各个元素,而又不需要暴露该对象的内部表示.使用场合:1.如果你希望提供访问一个聚合对象的内容,但是又不想暴露他的内部表示的时候,可以使用迭代器模式来提供迭代器接口,从而让客户端只是通过迭代器的接口来访问聚合对象,而无须关心聚合对象的内部实现.2.如果你希望有多种遍历方式可以访问聚合对象,可以使用...3.如果你希望为遍历不同的聚合对象提供一个统一的接口,可以使用....17.中介模式(Mediator) 发音:['mi:dieitə]定义:用一个中介对象类封装一系列对象的交互.中介者使得各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变他们之间的交互.使用场合:1.如果一组对象之间的通信方式比较复杂,导致相互依赖,结构混乱,可以采用中介模式,把这些对象相互的交互管理起来,各个对象都只需要和中介者交互,从而是的各个对象松散耦合,结构也更清晰易懂.2.如果一个对象引用很多的对象,并直接跟这些对象交互,导致难以复用该对象,可以采用中介者模式,把这个对象跟其他对象的交互封装到中介者对象里面,这个对象只需要和中介者对象交互就可了.18.备忘录模式(Memento)发音: [mɪ'mentəʊ]在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样以后就可将该对象恢复到原先保存的状态.使用场合:1.如果必须要保存一个对象在某一个时刻的全部或者部分状态,方便以后需要的时候,可以把该对象恢复到先前的状态,可以使用备忘录模式.2.如果需要保存一个对象的内部状态,但是如果用接口来让其他对象直接得到这些需要保存的状态,将会暴露对象的实现希捷并破坏对象的封装性,这是可以使用备忘录.19.观察者模式(Observer)发音: [əb'zɜːvə]定义:定义对象间的一种一对多的依赖关系.当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新.使用场合;1.当一个抽象模型有两个方面,其中一个方面的操作依赖于另一个方面的状态变化,那么就可以选用观察者模式,将这两者封装成观察者和目标对象,当目标对象变化的时候,依赖于它的观察者对象也会发生相应的变化.这样就把抽象模型的这两个方面分离了使得,它们可以独立地改变和复用.2.如果在更改一个对象的时候,需要同时连带改变其他对象,而且不知道究竟应该有多少对象需要被连带改变,这种情况可以选用观察者模式,被改的那一个对象很明显就相当于是目标对象,而需要连带修改的对歌其他对象,就作为多个观察着对象了.3.当一个对象必须通知其他的对象,但是你又希望这个对象和其他被它通知的对象是松散耦合的,也就是说这个对象其实不详知道具体被通知的对象.这种情况可以选用观察者模式,这个对象就相当于是目标对象,而被它通知的对象就是观察者对象了.20.状态模式(State)发音: [steɪt]允许一个对象在其内部状态改变是改变它的行为.对象看起来似乎修改了他的类.使用场合:1.如果一个对象的行为取决于它的状态,而且它必须在运行时刻根据状态来改变它的行为,可以使用...来包状态和行为分离开.虽然分离了,但是状态和行为是有对应关系的,可以在运行期间,通过改变状态,就能够调用到该状态对应的状态处理对象上去从而改变对象的行为.2.如果一个操作中含有庞大的多分枝语句,而且这些分支依赖于该对象的状态,可以使用....把各个分支的处理分散包装到单独的对象处理类中,这样,这些分支对应的对象就可以不依赖于其他对象而独立变化了.21.策略模式(Strategy)发音: ['strætɪdʒɪ]定义:定义一系列的算法,把它们一个个封装起来,并且使他们可以相互替换.本模式使得算法可独立于使用它的客户而变化.使用场合;1.出现有许多相关的类,仅仅是行为有差别的情况下,可以使用策略模式来使用多个行为中的一个来配置一个类的方法,实现算法动态切换2.出现同一算法,有很多不同实现的情况下,可以使用策略模式来把这些"不同的实现"实现成为一个算法的类层次.3.需要封装算法中,有与算法相关数据的情况下,可以使用策略模式来避免暴露这些跟算法相关的数据结构.4.出现抽象一个定义了很多行为的类,并且是通过多个if-else语句来选择这些行为的情况下,可以使用策略模式来替换这些条件语句.22.模版方法模式(Template Method)发音:['templeɪt; -plɪt]定义:定义在一个操作中的算法框架,把一些步骤推迟到子类去实现.模版方法模式让子类不需要改变算法的结构而重新定义特定的算法步骤功能:1.能够解决代码的冗余问题2.把某些算法步骤延迟到子类3.易于扩展4.父类提供了算法框架,控制了算法的执行流程,而子类不能改变算法的流程,子类的方法的调用由父类的模版方法决定.5.父类可以把那些重要的,不允许改变的方法屏蔽掉,不让子类去复写他们.1.需要固定定义算法骨架,实现一个算法的不变的部分,并把可变的行为留给子类来实现的情况.2.各个子类中具有公共行为,应该抽取出来,集中在一个公共类中去实现,从而避免复杂的代码重复3.需要控制子类扩展的情况.模版方法模式会在特定的点来调用子类的方法,这样只允许在这些点进行扩展.知识:回调:表示一段可执行逻辑的引用(或者指针),我们把该引用(或者指针)传递到另外一段逻辑(或者方法)里供这段逻辑适时调用(网站:)23.访问者模式(Visitor)发音:['vɪzɪtə]定义:表示一个作用于某对象结构中的各个元素的操作.它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作.使用场合:1.如果想对一个对象结构实施一些依赖于对象结构中具体类的操作,可以使用访问者模式.2.如果想对一个对象结构中的各个元素进行很多不同的而且不相关的操作,为了避免这些操作使类变得杂乱,可以使用访问者模式.3.如果对象结构很少变动,但是需要经常给对象结构中的元素定义新的操作,可以使用访问者模式.3.如果对象结构很少变动,但是需要经常给对象结构中的元素定义新的操作,可以使用访问者模式.。
java23种设计模式及其应用场景
创建型模式•单例模式（Singleton）：确保一个类只有一个实例。
–应用场景：数据库连接池、日志记录、缓存系统。
•工厂方法模式（Factory Method）：定义一个创建对象的接口，但让子类决定实例化哪个类。
–应用场景：提供创建对象的灵活性，允许在不改变代码的情况下更换创建逻辑。
•抽象工厂模式（Abstract Factory）：提供一个创建一系列相关或依赖对象的接口，而无需指定具体的类。
–应用场景：创建复杂的对象结构，需要保持多个对象之间的一致性。
•建造者模式（Builder）：将一个复杂对象的构建与它的表示分离，使其能够一步一步创建。
–应用场景：创建复杂的对象，需要自定义不同的配置或属性。
•原型模式（Prototype）：通过复制一个现有的对象来创建新的对象。
–应用场景：创建大量相似对象时，避免重复创建的开销。
结构型模式•适配器模式（Adapter）：将一个类的接口转换成另一个类所期望的接口。
–应用场景：将不兼容的类或系统集成在一起。
•桥接模式（Bridge）：将抽象部分与实现部分解耦，使它们可以独立变化。
–应用场景：当需要在抽象层和实现层之间引入灵活性时。
•组合模式（Composite）：将对象组织成树形结构，以便以类似的方式处理单个对象和组合对象。
–应用场景：表示部分与整体之间的层次关系。
•装饰器模式（Decorator）：在不改变对象自身的情况下，向对象添加新的功能。
–应用场景：向对象添加可选项功能，避免创建新的子类。
•外观模式（Facade）：提供一个统一的界面来访问一个子系统，隐藏其内部复杂性。
–应用场景：简化对复杂系统的访问，降低客户端与子系统之间的耦合。
•享元模式（Flyweight）：使用共享的对象来减少内存开销和对象数量。
–应用场景：需要创建大量相同或相似对象时。
•代理模式（Proxy）：为另一个对象提供一个代理或替身，以便控制对该对象的访问。
–应用场景：为对象添加额外的功能，如访问控制、缓存、日志记录。
C#的23种设计模式简要介绍
先制定一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。
23、VISITOR—访问者模式：访问者模式的目的是封装一些施加于某种数据结构元素之上的操作。
一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。访问者模式适用于数据结构相对未定的系统，
合成模式就是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构表示出来。
合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。
9、DECORATOR—装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，
提供比继承更多的灵活性。动态给一个对象增加功能，这些功能可以再动态的撤消。增加由一些基本功能的排列组合而产生的非常大量的功能。
命令对象的等级结构中的对象的任何排列组合都是一个语言。
16、ITERATOR—迭代子模式：迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。
多个对象聚在一起形成的总体称之为聚集，聚集对象是能够包容一组对象的容器对象。
迭代子模式将迭代逻辑封装到一个独立的子对象中，从而与聚集本身隔开。迭代子模式简化了聚集的界面
命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。
命令模式允许请求的一方和发送的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，
以及操作是否执行，何时被执行以及是怎么被执行的。系统支持命令的撤消。
15、INTERPRETER—解释器模式：给定一个语言后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。
中介者模式在多人游戏中的实际应用
中介者模式在多人游戏中的实际应用中介者模式（Mediator Pattern）是一种行为型设计模式，用于解耦多个对象之间的关联关系。
它通过将对象之间的通信行为抽离到一个中介者对象中，从而实现各个对象之间的松耦合。
在多人游戏中，中介者模式能够有效地管理和调度玩家之间的交互行为，提供良好的游戏体验。
本文将探讨中介者模式在多人游戏中的实际应用。
一、背景介绍多人游戏中，玩家之间需要进行各种交互和协作，例如发送消息、传递物品、进行团队战斗等。
在这个过程中，如果没有一个中心化的调度机制，玩家之间的关系将变得混乱和复杂，可能出现争夺资源、频繁的消息发送等问题。
而中介者模式正是为了解决这类问题而被引入。
二、中介者模式的原理中介者模式的核心概念是中介者对象（Mediator），它负责协调各个相关对象之间的通信行为。
中介者对象通常需要维护一个用于存储各个相关对象引用的列表，以便能够进行消息的转发和交流。
实际上，中介者模式就是将对象之间的交互行为封装在中介者对象中，并且让对象直接与中介者进行通信，而非直接与其他对象进行通信。
这样一来，当某个对象需要进行通信时，只需通过中介者对象发送消息即可，而不必关心其他对象的存在。
三、中介者模式在多人游戏中的应用1. 玩家之间的聊天在多人游戏中，玩家之间进行聊天交流是非常常见的情况。
如果没有中介者模式，每个玩家就需要与其他所有玩家进行通信，这样会导致复杂的消息处理和频繁的网络通信。
而通过引入中介者模式，可以将所有聊天消息发送给中介者对象，由中介者对象进行统一的消息处理和转发，从而减轻每个玩家的通信负担。
2. 跨地图传送在一些大型多人游戏中，存在多个地图或场景，玩家之间可能需要跨地图进行传送。
如果没有中介者模式，每个玩家在传送时都需要与其他所有玩家进行确认和同步。
而通过中介者模式，可以将传送请求发送给中介者对象，由中介者对象负责处理传送相关的逻辑，并将传送结果告知其他相关玩家，实现稳定和高效的跨地图传送。
23种设计模式分类
23种设计模式分类设计模式是软件开发中常用的经验总结和最佳实践的整理，可以帮助开发人员更高效、更可靠地构建软件系统。
根据《设计模式》一书的分类，设计模式可以分为23种不同的类型，每种类型都有其特定的目的和用途。
1. 创建型模式（Creational Patterns）- 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供一个全局访问点。
- 工厂方法模式（Factory Method Pattern）：定义一个创建对象的接口，但由子类决定实例化哪个类。
- 抽象工厂模式（Abstract Factory Pattern）：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
- 建造者模式（Builder Pattern）：将一个复杂对象的构建与其表示分离，使同样的构建过程可以创建不同的表示。
- 原型模式（Prototype Pattern）：通过复制现有对象来创建新对象，而不是通过实例化类。
2. 结构型模式（Structural Patterns）- 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另一个接口。
- 桥接模式（Bridge Pattern）：将抽象和实现部分分离，使它们可以独立变化。
- 装饰器模式（Decorator Pattern）：动态地为对象添加额外的职责。
- 外观模式（Facade Pattern）：提供了一个统一的接口，用于访问子系统中的一群接口。
- 享元模式（Flyweight Pattern）：通过共享模式来减少创建的对象数量，以减少内存占用。
- 代理模式（Proxy Pattern）：为其他对象提供一种代理以控制对这个对象的访问。
3. 行为型模式（Behavioral Patterns）- 责任链模式（Chain of Responsibility Pattern）：通过一条链传递请求，直到找到能够处理它的对象。
世界调制器模式程明再出发
世界调制器模式程明再出发
世界调制器模式是一种用来解决对象之间相互调用的问题的设计模式。
它通过引入一个调制器（Mediator）对象来封装对象之间的交互逻辑，将对象之间的直接通信转为通过调制器来进行间接通信。
这样可以降低对象之间的耦合度，提高系统的扩展性和可维护性。
在世界调制器模式中，调制器对象起到了类似调度中心的作用。
它负责管理对象之间的通信，并根据接收到的信息来决定如何调用其他对象的方法。
调制器对象将对象之间的通信逻辑抽象出来，使得每个对象只需关注自身的功能实现，不需要关注其他对象的具体实现。
当一个新的对象需要与其他对象进行通信时，它只需直接与调制器进行通信，而不需要直接与其他对象交互。
调制器会根据接收到的信息，将相关信息传递给对应的对象，并调用相应的方法进行处理。
世界调制器模式的再出发，可以在系统需要新增对象时，更方便地进行扩展和维护。
由于调制器对象承担了对象之间的通讯和调度任务，当新增对象时，只需对调制器对象进行适当的修改，无需修改其他对象的代码。
这样可以减少对原有代码的侵入性，降低引入新功能的风险。
总结来说，世界调制器模式的再出发可以提高系统的可扩展性和可维护性，降低对象之间的耦合度，使系统更易于拓展和维护。
mediatr 原理
mediatr 原理Mediatr 是一种 C# 库，它提供了一种基于中介者模式（Mediator Pattern）的实现方式，旨在简化应用程序的逻辑。
在使用 Mediatr 的情况下，所有的请求和响应都通过 Mediator 对象处理。
这个 Mediator 对象是应用程序逻辑的中心点，它包含了所有请求和响应的处理程序（Handler）。
每个请求和响应对象都需要实现相应的接口才能被处理，请求和响应对象的接口名称需要一致。
在使用 Mediatr 的过程中，开发者只需要定义请求和响应对象以及处理它们的 Handler，然后注册它们到 Mediator 对象中即可。
Mediator 委托应该响应的 Handler 处理请求或响应对象。
或者，如果没有响应对象，则可以简单地返回 null。
由于所有的请求和响应都由 Mediator 处理，所以开发者可以方便地实现聚合根（Aggregate Root）和领域驱动设计（Domain-driven Design）等架构模式。
当某个请求被发送到 Mediator 对象时，它会被路由到对应的Handler 进行处理，处理完成后将响应对象返回给 Mediator 对象。
接着，Mediator 对象将响应对象返回给请求者。
开发者不需要关心对象的实际处理流程，也无需关心请求和响应对象的格式。
Mediatr 使得应用程序的代码更为简洁、清晰，从而提高了开发效率。
总之，Mediatr 是一种基于中介者模式的 C# 库，它能够帮助开发者简化应用程序的逻辑。
使用 Mediatr，开发者可以定义请求和响应对象以及处理它们的 Handler，然后注册它们到 Mediator 对象中。
这个 Mediator 对象将负责发送请求、路由到对应的 Handler 进行处理、返回响应对象并最终将它返回给请求者，从而使得应用程序的代码更加简洁、清晰。
中介效应的代码
中介效应的代码中介模式（Mediator Pattern）是一种行为设计模式，它通过一个中介对象来协调其他相关对象之间的交互。
下面是一个简单的示例代码，展示了中介模式的实现：```csharpusing System;using System.Collections.Generic;// 中介者接口public interface IMediator{void SendMessage(string message, Colleague colleague);}// 具体中介者类public class ConcreteMediator : IMediator{private List<Colleague> colleagues = new List<Colleague>();public void RegisterColleague(Colleague colleague){colleagues.Add(colleague);}public void SendMessage(string message, Colleague sender){foreach (var colleague in colleagues){if (colleague != sender){colleague.ReceiveMessage(message);}}}}// 同事类public abstract class Colleague{protected IMediator mediator;public Colleague(IMediator mediator){this.mediator = mediator;}public void SendMessage(string message){mediator.SendMessage(message, this);}public abstract void ReceiveMessage(string message);}// 具体同事类public class ConcreteColleagueA : Colleague{public ConcreteColleagueA(IMediator mediator) : base(mediator) {}public override void ReceiveMessage(string message){Console.WriteLine("ConcreteColleagueA received message: " + message);}}public class ConcreteColleagueB : Colleague{public ConcreteColleagueB(IMediator mediator) : base(mediator) {}public override void ReceiveMessage(string message){Console.WriteLine("ConcreteColleagueB received message: " + message);}}// 使用示例public class Program{public static void Main(string[] args){// 创建中介者ConcreteMediator mediator = new ConcreteMediator();// 创建同事对象ConcreteColleagueA colleagueA = newConcreteColleagueA(mediator);ConcreteColleagueB colleagueB = newConcreteColleagueB(mediator);// 注册同事对象到中介者mediator.RegisterColleague(colleagueA);mediator.RegisterColleague(colleagueB);// 同事对象之间通过中介者进行通信colleagueA.SendMessage("Hello from ColleagueA");colleagueB.SendMessage("Hi from ColleagueB");Console.ReadLine();}}```在这个示例中，中介者模式的实现包括三个主要部分：中介者接口（IMediator）、具体中介者类（ConcreteMediator）和同事类（Colleague）。
Mediator模式在软件开发中的应用场景及优势分析
Mediator模式在软件开发中的应用场景及优势分析在软件开发中，设计模式是一种常用的方法论，用于解决各种问题和难题。
其中，Mediator模式是一种被广泛应用的设计模式，能够简化软件系统的复杂度，提高代码的可读性和可维护性。
本文将从应用场景和优势两个方面，分析Mediator模式在软件开发中的应用价值。
一、Mediator模式的应用场景1. 复杂的对象交互在软件开发过程中，有些场景需要集成多个对象进行交互，如果每个对象都直接联系其他对象，那么代码将变得很复杂，难以阅读和维护。
此时，Mediator模式可以派上用场。
Mediator模式通过将对象之间的交互集中在一个中介者对象中，实现了对象之间的解耦。
每个对象只需要和中介者对象打交道，而不需要考虑其他对象的具体实现，大大降低了代码的复杂程度。
2. 多个对象间的同步操作在一些场景中，多个对象需要完成某一操作，而且某些操作必须在其他操作完成之后才能执行。
这时，如果每个对象都负责协调其他对象的操作，就会产生很多冗余代码，并且容易产生死锁的问题。
Mediator模式可以通过让中介者对象协调所有对象的操作，确保操作按照正确的顺序执行，从而避免死锁的出现。
3. 多个对象之间的通信在某些场景下，多个对象之间需要频繁地进行通信，例如聊天室、在线游戏等场景。
如果每个对象都向其他对象发送消息，那么代码将变得很复杂，可以通过Mediator模式来简化代码的实现。
在Mediator模式中，通过引入中介者对象，所有对象都将自己的消息发送到中介者对象，中介者对象再将消息传递给其他对象。
这样，每个对象只需要和中介者对象交互，中介者对象负责传递消息，大大减少了对象之间的代码复杂度。
二、Mediator模式的优势分析1. 降低系统复杂度因为Mediator模式能够将复杂的对象之间的交互关系集中在一个中介者对象中，从而实现了对象之间的解耦，降低了代码的复杂度。
并且，中介者对象作为唯一的交互点，所有对象之间的通信必须经过中介者对象，从而减少了代码的耦合程度。