状态模式、职责链模式、组合模式--三个例子（大话设计模式考）

最新推荐文章于 2021-05-26 21:31:17 发布

weixin_33841722

最新推荐文章于 2021-05-26 21:31:17 发布

阅读量234

点赞数

原文链接：https://my.oschina.net/mahaisong/blog/160786

版权

2019独角兽企业重金招聘Python工程师标准>>>

输出的结果：

状态模式：

当前时间：9点，上午工作，精神百倍

当前时间：10点，上午工作，精神百倍
当前时间：12点饿了，午饭，犯困，午休
当前时间： 13 点下午状态还不错，继续努力
当前时间： 14 点下午状态还不错，继续努力
当前时间17点，加班哦，疲惫之极
当前时间19点，加班哦，疲惫之极
当前时间：22点不行了，睡着了。

当前时间：22，点下班回家了。

职责链模式：

总经理:请详细说明情况！
总经理:病假数量10 被总经理批准
总监:病假数量5 被总监批准
经理:病假数量1被经理批准
总经理:加薪数量500 被总经理批准
总经理:加薪数量600 总经理不批准！
总经理:不是请假，加薪申请，工作流程错误，一律不批准！
总经理:病假数量5 被总经理批准

组合模式：

结构图
-北京总公司
---总公司人力资源部
---总公司财务部
---上海华东分公司
-----上海华东分公司人力资源部
-----上海华东分公司财务部
---南京办事处
-----南京办事处人力资源部
-----南京办事处财务部
---杭州办事处
-----杭州办事处人力资源部
-----杭州办事处财务部

职责
总公司人力资源部员工招聘培训管理
总公司财务部公司收支管理
上海华东分公司人力资源部员工招聘培训管理
上海华东分公司财务部公司收支管理
南京办事处人力资源部员工招聘培训管理
南京办事处财务部公司收支管理
杭州办事处人力资源部员工招聘培训管理
杭州办事处财务部公司收支管理

代码：

主类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace WinServerTest1
{
    public class IntoMain
    {

        public IntoMain()
        {
         
        }

        /// <summary>
        /// 状态模式
        /// </summary>
        public void StatePattern()
       {
           //执行开始
           Work happyproject = new Work();
           happyproject.Hour = 9;
           happyproject.WriteProgram();
           happyproject.Hour = 10;
           happyproject.WriteProgram();
           happyproject.Hour = 12;
           happyproject.WriteProgram();
           happyproject.Hour = 13;
           happyproject.WriteProgram();
           happyproject.Hour = 14;
           happyproject.WriteProgram();
           happyproject.Hour = 17;
           happyproject.WriteProgram();
           happyproject.TaskFinished = false;
           happyproject.Hour = 19;
           happyproject.WriteProgram();//并没有换状态。
           happyproject.Hour = 22;
           happyproject.WriteProgram();//换状态。
           Console.Read();
        }

        /// <summary>
        /// 职责链条模式
        /// </summary>
        public void ChainPattern()
        {
            //这里这么多请求，还可以做成事件的绑定方式。 当然不需要的话直接用LIST就可以，不要过度设计。


            CommonManager jinli = new CommonManager("经理");
            Majordomo zongjian = new Majordomo("总监");
            GeneralMananger zhongjingli = new GeneralMananger("总经理");

            jinli.SetSuperior(zongjian);
            zongjian.SetSuperior(zhongjingli);

            Request request = new Request();
            request.RequestType = "请假";
            request.RequestContent = "病假";
            request.Number = 100;
            jinli.RequestApplication(request); //所有流程构建后，从最初流程进入，并不知道具体管理负责的类。


            Request request1 = new Request();
            request1.RequestType = "请假";
            request1.RequestContent = "病假";
            request1.Number =10;
            jinli.RequestApplication(request1);


            Request request2 = new Request();
            request2.RequestType = "请假";
            request2.RequestContent = "病假";
            request2.Number = 5;
            jinli.RequestApplication(request2);

            Request request3 = new Request();
            request3.RequestType = "请假";
            request3.RequestContent = "病假";
            request3.Number = 1;
            jinli.RequestApplication(request3);


            Request request4 = new Request();
            request4.RequestType = "加薪";
            request4.RequestContent = "加薪";
            request4.Number = 500;
            jinli.RequestApplication(request4);


            Request request5 = new Request();
            request5.RequestType = "加薪";
            request5.RequestContent = "加薪";
            request5.Number = 600;
            jinli.RequestApplication(request5);

            Request request6 = new Request();
            request6.RequestType = "旅游";
            request6.RequestContent = "旅游";
            request6.Number = 7;
            jinli.RequestApplication(request6);


            //更改当前的工作流程， 请假工作直接走向新的特殊流程，请假5天，直接走总经理流程，跳过总监。

            jinli.SetSuperior(zhongjingli);
            jinli.RequestApplication(request2);//请假5天，本来总监能批准，但是他不批，于是直接找总经理。

            //问题1： 注意总经理的范围， 一开始是 >5 <10. 但是5到总经理那里就成了不能批准了，于是修改，改成0-10

            //问题2： 这种职责链条的维护比较麻烦，比如，我这个需要做单独的处理， 下面还有很多需要做正常的处理， 
            //        还需要再次重新绑定整个序列。 如果很多种形式，则很麻烦。 
            //        维护方式，做接入和去除工作。和链表一样。   
            //例如， 做删除总监操作。 则把总监的后指向赋给经理。 但是需要首先做好基础定义。 
            //     在需要还原的话，就把 做插入方法， 把经理的后指向（总经理）给总监，把经理的指向赋成总监。
            //     抽象类包装好此方法，将会好很多。  

            // 同时，单独需要的最好单独定义。 因为这种改动将会导致 链条混乱，除非有链条控制器。

            Console.Read();

        }

        /// <summary>
        /// 组合模式
        /// </summary>
        public void CombinePattern() 
        {
            ConcreteCompany root = new ConcreteCompany("北京总公司");
            root.Add(new HRDepartment("总公司人力资源部"));
            root.Add(new FinanceDepartment("总公司财务部"));

            ConcreteCompany comp = new ConcreteCompany("上海华东分公司");
            comp.Add(new HRDepartment("上海华东分公司人力资源部"));
            comp.Add(new FinanceDepartment("上海华东分公司财务部"));
            root.Add(comp);


            ConcreteCompany comp1 = new ConcreteCompany("南京办事处");
            comp1.Add(new HRDepartment("南京办事处人力资源部"));
            comp1.Add(new FinanceDepartment("南京办事处财务部"));
            root.Add(comp1);

            ConcreteCompany comp2 = new ConcreteCompany("杭州办事处");
            comp2.Add(new HRDepartment("杭州办事处人力资源部"));
            comp2.Add(new FinanceDepartment("杭州办事处财务部"));
            root.Add(comp2);

            Console.WriteLine("\n结构图");
            root.Display(1);
            Console.WriteLine("\n职责");
            root.LineOfDuty();
            Console.Read();
        }

    }
}

状态模式：StatePattern.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace WinServerTest1
{
    ///<!--状态模式实例-->

    #region 操作端
    /// <summary>
    /// 具体的工作对象，定义当前工作的属性与值， 利用State做状态对象。利用状态对象的参数传递WORK，针对此WORK做状态的切换。并且在切换中配置新的工作的属性与值，调用工作的状态执行方法。
    /// </summary>
    /// <remarks>
    /// 1.关于工作对象中的各种状态和属性以及记录操作等，都可以在Work类中加入，并在状态对象中调用WORK对象实现。
    /// 2.利用抽象类解耦，但是传递WORK对象也是一种耦合，这种耦合在面向对象中反而是必须的。就好像参数是object\int一样。
    /// 3.状态模式解除的是在WORK中出现非常多的状态判断的情况。
    /// </remarks>
    public class Work
    {

        private State current;//因为是抽象类，所以解耦，而且抽象类指明是父子关系。接口指规范行为。

        public Work() {

            current = new ForenoonState();//状态子类
        }

        /// <summary>
        /// 时间段
        /// </summary>
        private double hour;
        public double Hour {
            get { return hour; }
            set { hour = value; }
        }

       /// <summary>
       /// 任务--是否完成（整个工作流程）
       /// </summary>
        private bool finish = false;
        public bool TaskFinished 
        {
            get { return finish; }
            set { finish = value; }
        }


        public void SetState(State s)//声明，方便以后使用，其实利用WriteProgram就可以做好状态传递。但是如果要扩展职责链条，有必要做扩展。
        {
            current = s;//状态切换
        }


        public void WriteProgram() 
        {
            current.WriteProgram(this);//调用具体状态的State状态子类的方法。 传递WORK。
        }


    }

    public abstract class State
    {
        public abstract void WriteProgram(Work k);
    }


    public class ForenoonState : State 
    {

        public override void WriteProgram(Work w) 
        {
            if (w.Hour < 12)
            {
                Console.WriteLine("当前时间：{0}点， 上午工作，精神百倍",w.Hour);
            }
            else
            {
                w.SetState(new NoonState()); //按照指定顺序流程 调用WORK对象中的方法 更改下一个状态。
                 //也可以，在执行某个操作，通过操作判断是否进入下一个状态，还是结束。
                       //操作可以是多种 方法模块的不同组合，可以使用组合模式。
                //还可以针对每个状态做各自的职责链条。 这个等职责模式搞出来之后再合并。
                
                w.WriteProgram();
            }
        }
    }

    public class NoonState : State 
    {

        public override void WriteProgram(Work w)
        {

            if (w.Hour < 13) {
                Console.WriteLine("当前时间：{0}点 饿了， 午饭，犯困， 午休",w.Hour);
            }
            else
            {
                w.SetState(new AfternoonState());
                w.WriteProgram();
            }
        }
    }

    public class AfternoonState : State 
    {
        public override void WriteProgram(Work w)
        {
            if (w.Hour < 17)
            {
                Console.WriteLine("当前时间： {0} 点下午状态还不错，继续努力", w.Hour);
            }
            else 
            {
                w.SetState(new EventingState());
                w.WriteProgram();
            }
        }
    }

    public class EventingState : State 
    {//17-21

        public override void WriteProgram(Work w) 
        {
            //正常下班--客户端类中使用WORK对象，进行WORK对象的属性的更新。
            if (w.TaskFinished) {

                w.SetState(new RestState());
                w.WriteProgram();
            } else
            {//加班
                if (w.Hour < 21)
                {
                    Console.WriteLine("当前时间{0}点，加班哦，疲惫之极",w.Hour);
                }
                else
                {
                    w.SetState(new SleepingState());
                    w.WriteProgram();
                
                }
            
            }
        
        }
    }

    public class SleepingState : State 
    {
        public override void WriteProgram(Work w) 
        {
            Console.WriteLine("当前时间：{0}点不行了，睡着了。",w.Hour);//加班睡着
            w.TaskFinished = true;
            w.SetState(new EventingState()); //状态之间可以转向，但是主要不要做成环了就行了。 
            //通过改变WORK的属性，做操作。 如果WORK 的属性和标记更多，则可以在每个状态中做更多的控制。
            //不过：状态模式本身就是为了解除过多的状态判断，如果里面再次嵌套，是否再次进行状态模式，这个要仔细考虑。
            w.WriteProgram();
        }

    }

    public class RestState : State 
    {

        public override void WriteProgram(Work w) 
        {
            Console.WriteLine("当前时间：{0}，点下班回家了。",w.Hour);
        }
    }

#endregion



#region 客户端

   //IntoMain
   // Execute()

#endregion

}

职责链模式：ChainPattern.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace WinServerTest1
{
    //请求信息， 也是向下传递的。
    public class Request 
    {
        //申请类型
        private string requestType;
        public string RequestType 
        {
            get { return requestType; }
            set { requestType = value; }
        }

       //申请内容
        private string requestContent;
        public string RequestContent 
        {
            get { return requestContent; }
            set { requestContent = value; }
        }

        //数量
        private int number;
        public int Number 
        {
            get { return number; }
            set { number = value; }
        }

    }


    /// <summary>
    /// 管理者抽象类。。 每个负责不同职责功能 工作流程的的链条。 
    /// </summary>
    public abstract class Manager 
    {
        protected string name;
        protected Manager superior;//向下的链条指向。  在部门中就是向上的领导。

        public Manager(string name) 
        {
            this.name = name;
        }

        public void SetSuperior(Manager superior) //更改向下链条。 与状态模式的WORK 不同的是， 本类做的是其他工作流的抽象父类定义。而WORK中状态改变非常频繁。
        {
            this.superior = superior;// 而这里基本是每个只定义一次。 利用Request的对象方法指向向下传递。
            //即，状态模式传递一个WORK。职责模式通过指向下一个链条做连状。 与WORK中不断变化的指向向下类似。

            //而，WORK中的状态改变是在具体的状态中指向下一条。 
            //链条模式是通过设置下一条直接做链接的改变。  可以在客户端控制。

            //从程序设计中，我的程序确实需要很多状态变化。 但是每一个判断之后有可能就是组合成一种新的链条顺序。
            //即，上一次需要某个环节， 本次不需要了。同是一个状态。 
            //这种情况， 我建议是 整体看做状态设计， 每个状态独立设计其不同判断下的链条组合。 链条走完了。可以走下一个状态。 

            //同样，因为状态的下次指向也无法确定，有可能从停电直接到结束。中间状态没有， 则状态也无法完全指定其下一个状态。
            //则可以对于状态抽象类做类似。
            //但是，状态模式主要是状态的分解。 职责模式主要是链条。  链条中的每个功能也有独立的，只是其切换是由链条控制的。 
            //请求信息也是向下传递的。不过不针对请求信息做 链条。 请求信息之做单独的封装数据传递。
            //而状态模式做状态改变。 其中是 包状态封装到其内部。 职责是把 此请求做为参数不停的通过链条传递。
            //只是侧重点不同， 其实request中如果封装做链条转换的方法，也可以使用。 当然这种使用是要切入 Manager 也就是
            //链条中的抽象父类，中的属性之间做碰撞，然后 利用 职责链对象 做下一个链条的转换。 
            //又因为，我的状态之间是可以替换的。所以做个结合。   状态中加入职责链条。 WORK继续传递，保持其状态转换的功能，
            //增加其状态指向的功能，具体状态中的数据打包成一个请求，然后进入此状态指定的请求链条， 做每一个操作。
            //这里状态指向，在状态模式中靠状态类做， 现在改成WORK做，则WORK就类似与一种链条。
            //链条其实可以改成状态模式， 比较是按照流程去做。这个思路确定，在具体实现中去构造把。
            //链条的好处就是可以客户端指定其上级。

            //批准，停止
            //状态也好， 职责链条也好，总是有停止，而且停止的位置也有可能不同，停止后则链条不再继续。
            //关于这个停止也要好好考虑考虑，其在状态中的停止代表不符合下一个状态进入的可能。
            //其在职责链条的停止，代表链条执行完成或者出现特殊故障。 一般来说，链条如果是按照模块来划分的功能，不是特别的契合
            //传递和职责覆盖结构， 拿来用就成了状态模式差不多的样子，要按流程走完。

            //鉴于上面的分析， 在状态的部分，做成状态模式和职责链模式的结合， 在具体状态下工作要执行的模块，利用组合模式。
              
            //为什么用组合模式， 因为在某个状态可以不去检测某种功能，而其他功能依然都是用，则各个状态都应该是小模块的组合。
            //这里的组合与真正的组合模式不同， 真正的组合模式是嵌套，不断嵌套，但是最初也是这种简单的叠加。其实算是基本的活字印刷术。
            //这样某个功能修改，改某一个类即可。
            //    某个功能删除添加，在指定状态下的组合中修改即可。
            
            //其状态改变也可以非常方面的修改指向。
        }

        abstract public void RequestApplication(Request request);
    
    }

    /// <summary>
    /// 经理类
    /// </summary>
    public class CommonManager : Manager 
    {
        public CommonManager(string name) :base(name)
        { 
        
        }

        public override void RequestApplication(Request request)//请求对象作为参数，传递
        {
            if (request.RequestType == "请假" && request.Number <= 2)//加入天数判断
            {
                Console.WriteLine("{0}:{1} 数量{2}被经理批准", name, request.RequestContent, request.Number);
            }
            else 
            { 
            
                 if(superior!=null)
                 {
                     superior.RequestApplication(request);//向下传递参数， 而在客户端已经设置本类的指向。
                 }
            }
        } 

    }

    /// <summary>
    /// 总监
    /// </summary>
    class Majordomo : Manager 
    {

        public Majordomo(string name) :base(name)
        { }

        public override void RequestApplication(Request request)
        {
            if (request.RequestType == "请假" && request.Number <= 5)//加入天数判断
            {
                Console.WriteLine("{0}:{1} 数量{2} 被总监批准", name, request.RequestContent, request.Number);
            }
            else 
            {

                if (superior != null) { superior.RequestApplication(request); }
            }
        }
    
    }

    //总经理
    class GeneralMananger : Manager 
    {
        public GeneralMananger(string name) : base(name) { }

        public override void RequestApplication(Request request)
        {

            switch (request.RequestType) 
            { 
                case "请假":
                    if (request.Number > 0 && request.Number<=10)
                        Console.WriteLine("{0}:{1} 数量{2} 被总经理批准", name, request.RequestContent, request.Number);
                    else
                        Console.WriteLine("总经理:请详细说明情况！", name, request.RequestContent, request.Number);
                        //if病孕特殊情况，批准，不批准。
                        //传递回个人，个人结束流程。。
                    break;

                case "加薪":
                    if ( request.Number <= 500)
                    {
                        Console.WriteLine("{0}:{1} 数量{2} 被总经理批准", name, request.RequestContent, request.Number);
                    }
                    else 
                    {
                        Console.WriteLine("{0}:{1} 数量{2} 总经理不批准！", name, request.RequestContent, request.Number);
                    }
                    break;
                default:
                    Console.WriteLine("总经理:不是请假，加薪申请，工作流程错误，一律不批准！", name, request.RequestContent, request.Number);
                    break;
            }
        }
    
    }







}

组合模式：CombinePattern.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace WinServerTest1
{
    /// <summary>
    /// 嵌套组合体现在抽象类中，分支类中叠加 抽象类。  即，实现抽象类、 根节点类、节点类3个类即可，其他的都是他们的组合。
    /// 组合的好处是一个方面调用，其子类中的各自的方法也都立即响应。 
    ///  对我来说，嵌套的东西很少。 但是可以把每个状态做成一个组合，一个组合中组合所有的功能模块，当然功能模块多是平行的。
    ///  至于嵌套可以先做出来，以后需要类似功能方便添加。
    /// </summary>
    public abstract class Company 
    {
        protected string name;
        public Company(string name) { this.name = name; }

        //不同的子类都实现不同

        public abstract void Add(Company com);//引用其子类，做组合嵌套使用
        public abstract void Remove(Company com);

        public abstract void Display(int depth);//显示
        public abstract void LineOfDuty();//执行职责

    }

    /// <summary>
    /// 具体公司类-- 树枝节点
    /// </summary>
    public class ConcreteCompany : Company
    {

        private List<Company> children = new List<Company>();
        public ConcreteCompany(string name) : base(name) { }

        public override void Add(Company com)
        {
          children.Add(com);
        
        }
        public override void Remove(Company com)
        {
          children.Remove(com);
        
        }

        /// <summary>
        /// 显示层次
        /// </summary>
        /// <param name="depth"></param>
        public override void Display(int depth) 
        {
            Console.WriteLine(new String('-',depth)+name);

            foreach(Company component in children) //这里 无法分辨是一个组合层次还是单组件。
            {
                component.Display(depth+2);// 但是利用这种层次+2，将每个组合向下逐渐  加两个字符。 嵌套的含义，非常的明显了。
            
            }
        
        }
        /// <summary>
        /// 履行职责
        /// </summary>
        public override void LineOfDuty()
        {
          foreach(Company component in children)
          {
              component.LineOfDuty();
          }

        }

    }


    class HRDepartment : Company
    {

        public HRDepartment(string name) : base(name) { }//继承抽象类的构造，否则可以自己写不同的构造函数。
        public override void Add(Company com)
        {
           
        }

        public override void Remove(Company com)
        {

        }

        public override void Display(int depth)
        {
            Console.WriteLine(new String('-',depth)+name);// 树叶与上面的树枝
        }

        public override void LineOfDuty()
        {
            Console.WriteLine("{0} 员工招聘培训管理",name);
        }
    
    }


    class FinanceDepartment : Company
    {

        public FinanceDepartment(string name) : base(name) { }
        public override void Add(Company com)
        {

        }

        public override void Remove(Company com)
        {

        }

        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + name);// 树叶与上面的树枝
        }

        public override void LineOfDuty()
        {
            Console.WriteLine("{0} 公司收支管理", name);
        }

    }

}