【笔记】大话设计模式24-28
文章目录
24 职责链模式
24.1 Example
阿三刚工作时，年底年终奖发的很少，很多大专生拿得比他都多。他只好硬着头皮去找主任说。
主任需要跟部门老总商量一下，能不能提高一下年终奖；部门老总也得要请示公司老总，看能不能加个年终奖；
这种模式就是职责链模式，每个对象都有自己的职责，用户发送一个请求，这个请求经过每个职责对象，只至被处理。
24.2 定义
职责链模式（Chain of Responsibility）:使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止
24.3 Show me the code
class Program
{
static void Main(string[] args)
{
Handler h1 = new ConcreteHandler1();
Handler h2 = new ConcreteHandler2();
Handler h3 = new ConcreteHandler3();
// 设置职责链的上家与下家
h1.SetSuccessor(h2);
h2.SetSuccessor(h3);
int[] requests = { 2, 5, 14, 22, 18, 3, 27, 20 };
// 循环给最小处理者提交请求，不同的数额，由不同权限处理者处理
foreach (int request in requests)
{
h1.HandleRequest(request);
}
Console.Read();
}
}
// 定义一个处理请示的接口
abstract class Handler
{
protected Handler successor;
// 设置继任者
public void SetSuccessor(Handler successor)
{
this.successor = successor;
}
// 处理请求的抽象方法
public abstract void HandleRequest(int request);
}
// 请求数在0到10之间则有权处理，否则转到下一位
class ConcreteHandler1 : Handler
{
public override void HandleRequest(int request)
{
if (request >= 0 && request < 10)
{
Console.WriteLine("{0} 处理请求 {1}",
this.GetType().Name, request);
}
else if (successor != null)
{
successor.HandleRequest(request); // 转移到下一位
}
}
}
// 请求数在10到20之间则有权处理，否则转到下一位
class ConcreteHandler2 : Handler
{
public override void HandleRequest(int request)
{
if (request >= 10 && request < 20)
{
Console.WriteLine("{0} 处理请求 {1}",
this.GetType().Name, request);
}
else if (successor != null)
{
successor.HandleRequest(request);
}
}
}
// 请求数在20到30之间则有权处理，否则转到下一位
class ConcreteHandler3 : Handler
{
public override void HandleRequest(int request)
{
if (request >= 20 && request < 30)
{
Console.WriteLine("{0} 处理请求 {1}",
this.GetType().Name, request);
}
else if (successor != null)
{
successor.HandleRequest(request);
}
}
}
24.4 总结
-
单一职责原则，实现解耦： 接收者和发送者都没有对方的明确信息，且链中的对象自己也并不知道链的结构。
结果是职责链可简化对象的相互连接，它们仅需保持一个指向其后继者的引用，而不需要保持它所有的候选者的引用。
-
开闭原则：可以随时地增加或修改处理一个请求的结构，增强了给对象指派职责的灵活性。
-
当需要使用不同方式处理不同种类的请求，并且请求类型和顺序预先未知时，可以使用职责链模式。
当然，如果处理必须按顺序处理多个处理者时，就可以使用该模式。
25 中介者模式
25.1 Example
阿三现在上班通勤都是使用电动车，很多路口是没有红绿灯的，或者即便有红绿灯，对于电动车驾驶者来说，也是可有可无的存在，没有汽车的时候，他们一般会无视红绿灯，直接通过。但这样会给后面来的汽车带来麻烦，明明是绿灯，他们必须得停下来，导致自己通行受阻。
因此，很多交警每天一大早，站在这些路口，充当一种“中介”，人为地调节电瓶车和汽车之间的通行时间，使得交通秩序处于一种有序状态。
25.2 定义
中介者模式（Mediator）:用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以对立地改变他们之间的交互。
25.3 Show me the code
来看看模拟的联合国职责的中介者模式代码
class Program
{
static void Main(string[] args)
{
UnitedNationsSecurityCouncil UNSC = new UnitedNationsSecurityCouncil();
USA c1 = new USA(UNSC);
Iraq c2 = new Iraq(UNSC);
UNSC.Colleague1 = c1;
UNSC.Colleague2 = c2;
c1.Declare("不准研制核武器，否则要发动战争！");
c2.Declare("我们没有核武器，也不怕侵略。");
Console.Read();
}
}
//联合国机构
abstract class UnitedNations
{
/// <summary>
/// 声明
/// </summary>
/// <param name="message">声明信息</param>
/// <param name="colleague">声明国家</param>
public abstract void Declare(string message, Country colleague);
}
//联合国安全理事会
class UnitedNationsSecurityCouncil : UnitedNations
{
private USA colleague1;
private Iraq colleague2;
public USA Colleague1
{
set { colleague1 = value; }
}
public Iraq Colleague2
{
set { colleague2 = value; }
}
public override void Declare(string message, Country colleague)
{
if (colleague == colleague1)
{
colleague2.GetMessage(message);
}
else
{
colleague1.GetMessage(message);
}
}
}
//国家
abstract class Country
{
protected UnitedNations mediator;
public Country(UnitedNations mediator)
{
this.mediator = mediator;
}
}
//美国
class USA : Country
{
public USA(UnitedNations mediator)
: base(mediator)
{
}
//声明
public void Declare(string message)
{
mediator.Declare(message, this);
}
//获得消息
public void GetMessage(string message)
{
Console.WriteLine("美国获得对方信息：" + message);
}
}
//伊拉克
class Iraq : Country
{
public Iraq(UnitedNations mediator)
: base(mediator)
{
}
//声明
public void Declare(string message)
{
mediator.Declare(message, this);
}
//获得消息
public void GetMessage(string message)
{
Console.WriteLine("伊拉克获得对方信息：" + message);
}
}
25.4 总结
- 中介者模式减少了各个Coleague的耦合，使得可以对立地改变和复用各个Colleague类和Mediator
- 由于把对象如何协作进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，这样关注的对象从对象各自本身的行为转移到它们之间的交互上来。
- 中介者模式一般用于一组对象以定义良好但是复杂的方式进行通信的场合，以及想定制一个分布在多个类中的行为，而又不想生成太多子类的场合。
26 享元模式
26.1 Example
大头以前的有专门做网站的同事。以前的套路就是做水务平台的是一套代码框架，如果有其他城市要做，就把代码搬过来，修改下对应内容和数据库存储路径等，而代码框架是不变的，所以最终会出现每个城市的水务网站看似不同，其实内在的代码框架是一样的，也就是生成了多个网站实例，这是一种资源浪费和冗余。
如何能够将核心代码框架抽离出来，形成独立的代码核心和数据库，通过标识调用不同的数据和页面图标即可，这就是享元模式。
26.2 定义
享元模式（Flyweight）:运用共享技术有效地支持大量细粒度的对象。
26.3 Show me the code
- 基础代码
class Program
{
static void Main(string[] args)
{
int extrinsicstate = 22;
FlyweightFactory f = new FlyweightFactory();
Flyweight fx = f.GetFlyweight("Q");
fx.Operation(--extrinsicstate);
Flyweight fy = f.GetFlyweight("C");
fy.Operation(--extrinsicstate);
Flyweight fz = f.GetFlyweight("J");
fz.Operation(--extrinsicstate);
UnsharedConcreteFlyweight uf = new UnsharedConcreteFlyweight();
uf.Operation(--extrinsicstate);
Console.Read();
}
}
// 享元工厂，用来创造并管理Flyweight对象。用来确保合理地共享Flyweight。
class FlyweightFactory
{
private Hashtable flyweights = new Hashtable();
public FlyweightFactory()
{
flyweights.Add("Q", new ConcreteFlyweight());
flyweights.Add("J", new ConcreteFlyweight());
flyweights.Add("J", new ConcreteFlyweight());
}
public Flyweight GetFlyweight(string key)
{
return ((Flyweight)flyweights[key]);
}
}
// 接口，通过这个接口，Flyweight可以接受并作用于外部状态
abstract class Flyweight
{
public abstract void Operation(int extrinsicstate);
}
// 为内部状态增加存储空间
class ConcreteFlyweight : Flyweight
{
public override void Operation(int extrinsicstate)
{
Console.WriteLine("具体Flyweight:" + extrinsicstate);
}
}
// 指不需要共享的Flyweight子类。Flyweight接口共享成为可能，并不强制共享
class UnsharedConcreteFlyweight : Flyweight
{
public override void Operation(int extrinsicstate)
{
Console.WriteLine("不共享的具体Flyweight:" + extrinsicstate);
}
}
- 网站的享元模式
class Program
{
static void Main(string[] args)
{
WebSiteFactory f = new WebSiteFactory();
WebSite fx = f.GetWebSiteCategory("产品展示");
fx.Use(new User("阿三"));
WebSite fy = f.GetWebSiteCategory("产品展示");
fy.Use(new User("大头"));
WebSite fz = f.GetWebSiteCategory("产品展示");
fz.Use(new User("小豆子"));
WebSite fl = f.GetWebSiteCategory("博客");
fl.Use(new User("王五"));
WebSite fm = f.GetWebSiteCategory("博客");
fm.Use(new User("钱六"));
WebSite fn = f.GetWebSiteCategory("博客");
fn.Use(new User("大批古"));
Console.WriteLine("得到网站分类总数为 {0}", f.GetWebSiteCount());
Console.Read();
}
}
//用户
public class User
{
private string name;
public User(string name)
{
this.name = name;
}
public string Name
{
get { return name; }
}
}
//网站工厂
class WebSiteFactory
{
private Hashtable flyweights = new Hashtable();
//获得网站分类
public WebSite GetWebSiteCategory(string key)
{
if (!flyweights.ContainsKey(key))
flyweights.Add(key, new ConcreteWebSite(key));
return ((WebSite)flyweights[key]);
}
//获得网站分类总数
public int GetWebSiteCount()
{
return flyweights.Count;
}
}
//网站
abstract class WebSite
{
public abstract void Use(User user);
}
//具体的网站
class ConcreteWebSite : WebSite
{
private string name = "";
public ConcreteWebSite(string name)
{
this.name = name;
}
public override void Use(User user)
{
Console.WriteLine("网站分类：" + name + " 用户：" + user.Name);
}
}
26.4 总结
如果一个应用程序使用了大量对象，而这些对象造成了很大的存储开销时就应该考虑使用享元模式；
27 解释器模式
27.1 Example
阿三最近喜欢看短视频，有一类挺有意思的。
工作几年的人，想跳槽再正常不过了，不过面试的时候，能不能听懂面试官或单位领导的画外之音，就决定了正常面试的互相理解程度。比如老板说我们这边可以发挥的空间很大，有人就会解释说这里没多少人，需要你干的任务比较多；老板说我们这里工作时间比较自由，有人解释，需要你加班的场景会比较多等等。搞笑的同时，确实和现实有几分相似。
因此，能不能正确解读HR和老板的话语，需要通过解释器帮助我们正确理解他人的真正意图。
27.2 定义
解释器模式（Interpreter）:给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
27.3 Show me the code
- 基本代码
class Program
{
static void Main(string[] args)
{
Context context = new Context();
IList<AbstractExpression> list = new List<AbstractExpression>();
list.Add(new TerminalExpression());
list.Add(new NonterminalExpression());
list.Add(new TerminalExpression());
list.Add(new TerminalExpression());
foreach (AbstractExpression exp in list)
{
exp.Interpret(context);
}
Console.Read();
}
}
class Context
{
private string input;
public string Input
{
get { return input; }
set { input = value; }
}
private string output;
public string Output
{
get { return output; }
set { output = value; }
}
}
// 抽象表达式，声明一个抽象的解释操作，这个接口为抽象语法树中所有节点所共享
abstract class AbstractExpression
{
public abstract void Interpret(Context context);
}
// 终结符表达式，实现与文法中的终结符相关联的解释操作。
class TerminalExpression : AbstractExpression
{
public override void Interpret(Context context)
{
Console.WriteLine("终端解释器");
}
}
// 非终结符表达式，为文法中的非终结符实现解释操作。
// 对文法中每一条规则R2、R2.....Rn都需要一个具体的非终结表达式类
class NonterminalExpression : AbstractExpression
{
public override void Interpret(Context context)
{
Console.WriteLine("非终端解释器");
}
}
结果：
终端解释器
非终端解释器
终端解释器
终端解释器
- 乐谱解释控制台代码实现：
class Program
{
static void Main(string[] args)
{
PlayContext context = new PlayContext();
//音乐-上海滩
Console.WriteLine("上海滩：");
//context.演奏文本 = "T 500 O 2 E 0.5 G 0.5 A 3 E 0.5 G 0.5 D 3 E 0.5 G 0.5 A 0.5 O 3 C 1 O 2 A 0.5 G 1 C 0.5 E 0.5 D 3 D 0.5 E 0.5 G 3 D 0.5 E 0.5 O 1 A 3 A 0.5 O 2 C 0.5 D 1.5 E 0.5 D 0.5 O 1 B 0.5 A 0.5 O 2 C 0.5 O 1 G 3 P 0.5 O 2 E 0.5 G 0.5 A 3 E 0.5 G 0.5 D 3 E 0.5 G 0.5 A 0.5 O 3 C 1 O 2 A 0.5 G 1 C 0.5 E 0.5 D 3 D 0.5 E 0.5 G 3 D 0.5 E 0.5 O 1 A 3 A 0.5 O 2 C 0.5 D 1.5 E 0.5 D 0.5 O 1 B 0.5 A 0.5 G 0.5 O 2 C 3 P 0.5 O 3 C 0.5 C 0.5 O 2 A 0.5 O 3 C 2 P 0.5 O 2 A 0.5 O 3 C 0.5 O 2 A 0.5 G 2.5 G 0.5 E 0.5 A 1.5 G 0.5 C 1 D 0.25 C 0.25 D 0.5 E 2.5 E 0.5 E 0.5 D 0.5 E 2.5 O 3 C 0.5 C 0.5 O 2 B 0.5 A 3 E 0.5 E 0.5 D 1.5 E 0.5 O 3 C 0.5 O 2 B 0.5 A 0.5 E 0.5 G 2 P 0.5 O 2 E 0.5 G 0.5 A 3 E 0.5 G 0.5 D 3 E 0.5 G 0.5 A 0.5 O 3 C 1 O 2 A 0.5 G 1 C 0.5 E 0.5 D 3 D 0.5 E 0.5 G 3 D 0.5 E 0.5 O 1 A 3 A 0.5 O 2 C 0.5 D 1.5 E 0.5 D 0.5 O 1 B 0.5 A 0.5 G 0.5 O 2 C 3 ";
context.PlayText = "T 500 O 2 E 0.5 G 0.5 A 3 E 0.5 G 0.5 D 3 E 0.5 G 0.5 A 0.5 O 3 C 1 O 2 A 0.5 G 1 C 0.5 E 0.5 D 3 ";
//音乐-隐形的翅膀
//Console.WriteLine("隐形的翅膀：");
//context.演奏文本 = "T 1000 O 1 G 0.5 O 2 C 0.5 E 1.5 G 0.5 E 1 D 0.5 C 0.5 C 0.5 C 0.5 C 0.5 O 1 A 0.25 G 0.25 G 1 G 0.5 O 2 C 0.5 E 1.5 G 0.5 G 0.5 G 0.5 A 0.5 G 0.5 G 0.5 D 0.25 E 0.25 D 0.5 C 0.25 D 0.25 D 1 A 0.5 G 0.5 E 1.5 G 0.5 G 0.5 G 0.5 A 0.5 G 0.5 E 0.5 D 0.5 C 0.5 C 0.25 D 0.25 O 1 A 1 G 0.5 A 0.5 O 2 C 1.5 D 0.25 E 0.25 D 1 E 0.5 C 0.5 C 3 O 1 G 0.5 O 2 C 0.5 E 1.5 G 0.5 E 1 D 0.5 C 0.5 C 0.5 C 0.5 C 0.5 O 1 A 0.25 G 0.25 G 1 G 0.5 O 2 C 0.5 E 1.5 G 0.5 G 0.5 G 0.5 A 0.5 G 0.5 G 0.5 D 0.25 E 0.25 D 0.5 C 0.25 D 0.25 D 1 A 0.5 G 0.5 E 1.5 G 0.5 G 0.5 G 0.5 A 0.5 G 0.5 E 0.5 D 0.5 C 0.5 C 0.25 D 0.25 O 1 A 1 G 0.5 A 0.5 O 2 C 1.5 D 0.25 E 0.25 D 1 E 0.5 C 0.5 C 3 E 0.5 G 0.5 O 3 C 1.5 O 2 B 0.25 O 3 C 0.25 O 2 B 1 A 0.5 G 0.5 A 0.5 O 3 C 0.5 O 2 E 0.5 D 0.5 C 1 C 0.5 C 0.5 C 0.5 O 3 C 1 O 2 G 0.25 A 0.25 G 0.5 D 0.25 E 0.25 D 0.5 C 0.25 D 0.25 D 3 E 0.5 G 0.5 O 3 C 1.5 O 2 B 0.25 O 3 C 0.25 O 2 B 1 A 0.5 G 0.5 A 0.5 O 3 C 0.5 O 2 E 0.5 D 0.5 C 1 C 0.5 C 0.5 C 0.5 O 3 C 1 O 2 G 0.25 A 0.25 G 0.5 D 0.25 E 0.25 D 0.5 C 0.5 C 3 ";
Expression expression = null;
try
{
while (context.PlayText.Length > 0)
{
string str = context.PlayText.Substring(0, 1);
switch (str)
{
case "O":
expression = new Scale();
break;
case "T":
expression = new Speed();
break;
case "C":
case "D":
case "E":
case "F":
case "G":
case "A":
case "B":
case "P":
expression = new Note();
break;
}
expression.Interpret(context);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.Read();
}
}
//演奏内容
class PlayContext
{
//演奏文本
private string text;
public string PlayText
{
get { return text; }
set { text = value; }
}
}
//表达式
abstract class Expression
{
//解释器
public void Interpret(PlayContext context)
{
if (context.PlayText.Length == 0)
{
return;
}
else
{
string playKey = context.PlayText.Substring(0, 1);
context.PlayText = context.PlayText.Substring(2);
double playValue = Convert.ToDouble(context.PlayText.Substring(0, context.PlayText.IndexOf(" ")));
context.PlayText = context.PlayText.Substring(context.PlayText.IndexOf(" ") + 1);
Excute(playKey, playValue);
}
}
//执行
public abstract void Excute(string key, double value);
}
//音符
class Note : Expression
{
public override void Excute(string key, double value)
{
string note = "";
switch (key)
{
case "C":
note = "1";
break;
case "D":
note = "2";
break;
case "E":
note = "3";
break;
case "F":
note = "4";
break;
case "G":
note = "5";
break;
case "A":
note = "6";
break;
case "B":
note = "7";
break;
}
Console.Write("{0} ", note);
}
}
//音阶
class Scale : Expression
{
public override void Excute(string key, double value)
{
string scale = "";
switch (Convert.ToInt32(value))
{
case 1:
scale = "低音";
break;
case 2:
scale = "中音";
break;
case 3:
scale = "高音";
break;
}
Console.Write("{0} ", scale);
}
}
//音速
class Speed : Expression
{
public override void Excute(string key, double value)
{
string speed;
if (value < 500)
speed = "快速";
else if (value >= 1000)
speed = "慢速";
else
speed = "中速";
Console.Write("{0} ", speed);
}
}
27.4 总结
- 当有一个语言需要解释执行，并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式；
- 优点：比较容易改变和扩展文法，因为该模式使用类来表示文法规则，可使用继承实现；也比较容易实现文法，因为定义抽象语法树中各个节点的类的实现大体类似，这些类都易于直接编写。
- 缺点：每个文法中的每一条规则至少定义了一个类，因为包含许多规则的文法可能难以管理和维护。
- 建议：当文法非常复杂时，使用其他的技术如语法分析程序或编译器生成器来处理。
28访问者模式
28.1 Example
大头平时喜欢吃汉堡之类的快餐。
因此每次去快餐店，大头总是先了解一下快餐店最近的促销产品，然后了解一下所有可购买产品的状态，再根据自己的喜好进行购买。这就是访问者模式。访问一个对象，可以对这个对象所有子类进行读取。
28.2 定义
访问者模式（Visitor）:表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作
28.3 Show me the code
class Program
{
static void Main(string[] args)
{
ObjectStructure o = new ObjectStructure();
o.Attach(new ConcreteElementA());
o.Attach(new ConcreteElementB());
ConcreteVisitor1 v1 = new ConcreteVisitor1();
ConcreteVisitor2 v2 = new ConcreteVisitor2();
o.Accept(v1);
o.Accept(v2);
Console.Read();
}
}
abstract class Visitor
{
public abstract void VisitConcreteElementA(ConcreteElementA concreteElementA);
public abstract void VisitConcreteElementB(ConcreteElementB concreteElementB);
}
class ConcreteVisitor1 : Visitor
{
public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
{
Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name);
}
public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
{
Console.WriteLine("{0}被{1}访问", concreteElementB.GetType().Name, this.GetType().Name);
}
}
class ConcreteVisitor2 : Visitor
{
public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
{
Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name);
}
public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
{
Console.WriteLine("{0}被{1}访问", concreteElementB.GetType().Name, this.GetType().Name);
}
}
abstract class Element
{
public abstract void Accept(Visitor visitor);
}
class ConcreteElementA : Element
{
public override void Accept(Visitor visitor)
{
visitor.VisitConcreteElementA(this);
}
public void OperationA()
{ }
}
class ConcreteElementB : Element
{
public override void Accept(Visitor visitor)
{
visitor.VisitConcreteElementB(this);
}
public void OperationB()
{ }
}
class ObjectStructure
{
private IList<Element> elements = new List<Element>();
public void Attach(Element element)
{
elements.Add(element);
}
public void Detach(Element element)
{
elements.Remove(element);
}
public void Accept(Visitor visitor)
{
foreach (Element e in elements)
{
e.Accept(visitor);
}
}
}
28.4 总结
- 访问者模式适用于数据结构相对稳定的系统，将数据结构和作用于结构上的操作耦合解脱开，使得操作集合可以相对自由地演化。
- 当你需要对一个复杂对象结构，如对象树中所有元素执行某些操作，可使用访问者模式；
- 优点：增加新的访问者，即增加新操作比较容易。访问者模式将有关行为集中到一个访问者对象中。
- 缺点：增加新的数据结构比较困难，有的操作需要重新修改。
扫一扫
234
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
