设计模式总结-行为模式

最新推荐文章于 2021-06-01 20:54:35 发布

心心念念的小鼠标

最新推荐文章于 2021-06-01 20:54:35 发布

阅读量1.2k

点赞数 2

分类专栏：设计模式文章标签：行为型模式模板方法模式访问者模式职责链模式

本文链接：https://blog.csdn.net/huo065000/article/details/24578431

版权

●技术分享和架构设计同时被 2 个专栏收录

49 篇文章 0 订阅

订阅专栏

设计模式

22 篇文章 0 订阅

订阅专栏

分类：

了解了这么多模式，在学习的过程中也设计到了很多行为模式，至于有哪些？可以一一道来。

迭代器模式	http://blog.csdn.net/huo065000/article/details/24352437
中介者模式	http://blog.csdn.net/huo065000/article/details/22856883
备忘录模式	http://blog.csdn.net/huo065000/article/details/24233429
观察者模式	http://blog.csdn.net/huo065000/article/details/22933081
状态模式	http://blog.csdn.net/huo065000/article/details/23021919
策略模式	http://blog.csdn.net/huo065000/article/details/21286775
模板方法模式	下文
访问者模式	下文
职责连模式	下文
命令模式	http://blog.csdn.net/huo065000/article/details/24587949

行为包括这么多，那么到底什么是行为模式呢？

定义：

行为模式是对在不同的对象之间划分责任和算法的抽象化。行为模式不仅仅是关于类和对象的，而且是关于它们之间的相互作用的。可分为类的行为模式和对象的行为模式。

类的行为模式：类的行为模式使用继承关系在几个类之间分配行为

对象的行为模式：使用对象的聚合来分配行为

模板方法模式：

看到这个模式第一感觉就是照葫芦画瓢的一个模式，应该算是最常用的一种模式吧！最近临近毕业，很喜欢那些在外打工的同胞回来看我，因为回来就可以请我吃大餐啊！对于吃饭，当然也有固定的模式，点单-吃东西-买单。就这么简单的一个流程呗！关键就在于点什么餐了点单，买单的过程是重复的，所有重复的代码可以上升到父类，而不是让每个点餐都重复这个过程。这就是所谓的模仿方法模式。

定义：

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

结构图：

基本代码：

AbstractClass是抽象类，其实也就是一抽象模板，定义并实现了一个模板方法。

abstract  class AbstractClass
        {
            public abstract void PrimitOperation1();  //一些抽象行为，放到子类去实现
            public abstract void PrimitOperation2();
            public void TemplateMethod()    //模板方法，给出了逻辑的骨架，而逻辑的组成是一些相应的抽象操作，它们都推迟到子类实现
            {
                PrimitOperation1();
                PrimitOperation2();
                Console.WriteLine("");
            }

ConcreteClass，实现父类所定义的一个或多个抽象方法。每一个AbstractClass都可以有任意多个ConcreteClass与之对应，而每一个ConcreteClass都可以给出这些抽象方法的不同实现，从而使得顶级逻辑的实现各有不相同

class ConcreteClassA:AbstractClass
        {
            public override void PrimitOperation1()
            {
                Console.WriteLine("具体类A方法1实现");   //与ConcreteClassB不同的方法实现
            }
            public override void PrimitOperation2()
            {
                Console.WriteLine("具体类A方法2实现");
            }
        }

客户端调用：

static void Main(string[] args)
        {
            AbstractClass c;
            c = new ConcreteClassA();
            c.TemplateMethod();

            Console.Read();
        }

职责连模式：

“工作这么长时间了，为什么就不给我涨工资呢？”满含抱怨的口气说道。

“我也想给你长工资啊！看着你每天的尽心尽力，可是我没有这个权利啊！”经理很耐心的讲述到。

“如果你是因为什么事情而请假一两天的话，我到可以有这个权利处理，可是毕竟财政大权不在咱们手里啊！心有余而力不足……”经理补充道。

其实我也知道经理人好，所以本以为这件事情就这样不了了之了，可是某天经理说总经理同意给你加工资了，你在公司的表现都众人皆知。这样当然就高兴了！

把自己处理不了的事情交给下一个人，总会有一个能够有权利来解决。这就是所谓的职责连模式。

结构图：

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

客户端代码，向链上的具体处理者对象提交请求

static void Main(string[] args)
        {
            Handler h1 = new ConcreteHandler1();
            //此处有h2和h3……
            h1.SetSuccessor(h2);   //设置职责链上家与下家

            int[] requests = { 2, 5, 12, 17 };
            foreach (int request int requests )   //循环给最小处理者提交请求，不同的数额，由不同权限处理者处理
            {
               h1 .HandlerRequest (request);
            }
            Console .Read ();
        }

Handler类，处理一个处理请示的接口

 abstract class Handler
        {
            protected Handler successor;
            public void SetSuccessor(Handler successor)  //设置继任者
            {
                this.successor = successor;
            }
            public abstract void HandlerRequest(int request); //处理请求的抽象方法
        }

具体的处理者对象类

 class ConcreteHandler1:Handler
        {
            public override void HandlerRequest(int request)
            {
                if (request >=0 && request <10)   //0到10处理此请求
                {
                    Console.WriteLine("{0} 处理请求 {1}", this.GetType().Name, request);
                }
                else if (successor !=null )
                {
                    successor.HandlerRequest(request);  //转移到下一位
                }
            }

好处：

使用此模式，最主要的目的是想让请求不间断，而且我还可以随时地增加或修改处理一个请求的结构。增强了给对象指派职责的灵活性。当然如果一个请求有可能到了链的末端都得不到处理，或者因为没有正确配置而得不到处理，这就很糟糕了，所以在使用的时候一定要考虑全面。