状态模式、职责链模式——省去if-else的繁琐结构

小时候写日记都是这么写的：上午七点起床，八点以前洗脸刷牙吃早饭，十二点以前好好上课，中午一点，吃午餐，下午两点到六点，上课，下课，找请假，明天妈妈要带我去姥姥家，九点以前，看动画片，九点钟，收拾去姥姥家的东西，十点之后，睡觉。

咱们把请假这块在充实一下：找班长请假，班长只能请半天，不然班长向老师申请，若是请假时间超过一周，老师要跟副年级主任请示，若是请假超出一个月，主任要跟年级正主任请示，而后被批准，或不被批准。

若是用编程语言描述这两件事情，应该是这个样子的。

 

public class DayWork
{
    private int hour;


    public void writeProgram()
    {
        if (hour < 7)
        {
            System.out.println("当前时间：" + hour + "点 睡觉");
        }
        else if (hour = 7)
        {
            System.out.println("当前时间：" + hour + "洗脸刷牙吃早饭");
        }
        else if (hour < 12)
        {
            System.out.println("当前时间：" + hour + "点 好好上课");
        }
        else if(hour=1)
        {
            System.out.println("当前时间：" + hour + "点 吃午餐");

        }
        else if(hour<18)
        {
            System.out.println("当前时间：" + hour + "点 好好学习");

        }
    }

    public int getHour()
    {
        return hour;
    }

    public void setHour(int hour)
    {
        this.hour = hour;
    }


}
//客户端代码
public class Main
{
    public static void main(String[] args)
    {
        DayWork work = new Work();
        work.setHour(9);
        work.writeProgram();
        work.setHour(10);
        work.writeProgram();
        work.setHour(12);
        work.writeProgram();
        work.setHour(13);
        work.writeProgram();
        work.setHour(14);
        work.writeProgram();

    }
}

 

而请假的代码和这个差很少，if 请半天，班长请，else if 一周之内，老师请 else if 一个月之内 副主任请，else 超过一个月 主任请。

但是，拿日记例子来看，过多的if分支并非一件好事，它首先不知足开闭原则，一旦须要修改整个IF语句都须要修改，责任没有费解，也不符合单一职责原则，咱们但愿分解整个行为，把状态的判断逻辑转移到表示不一样状态的一系列类当中，把复杂的判断逻辑简化，这就是咱们所说的状态模式。

状态模式结构图：

 

状态模式代码实现：

 

//State类，抽象状态类，定义一个接口以封装与Context的一个特定状态相关的行为
public interface State
{
    public void handle(Context context);
}
//ConcreteState类，具体状态，每个子类实现一个与Context的一个状态相关的行为。
public class ConcreteStateA implements State
{
    public void handle(Context context)
    {
        context.setState(new ConcreteStateB());
    }
}
public class ConcreteStateB implements State
{
    public void handle(Context context)
    {
        context.setState(new ConcreteStateA());
    }
}
//Context类，维护一个ConcreteState子类的实例，这个实例定义当前的状态
public class Context
{
    private State   state;

    public Context(State state)
    {
        this.state = state;
    }

    public void request()
    {
        state.handle(this);
    }

    public State getState()
    {
        return state;
    }

    public void setState(State state)
    {
        this.state = state;
        System.out.println("当前状态：" + state.getClass().getName());
    }
}
//客户端代码
public class Main
{
    public static void main(String[] args)
    {
        Context context = new Context(new ConcreteStateA());

        context.request();
        context.request();
        context.request();
        context.request();
    }
}

状态模式将特定的状态相关的行为都放入一个对象中，因为全部与状态相关的代码都存在于某个ConcreteState中，因此经过定义新的子类能够很容易地增长新的状态和转换。

 

并且，状态模式把各类状态转移逻辑分布到State的子类之间，来减小相互间的依赖。

请假问题也是一个很复杂的条件表达式，安理说用状态模式是可使用的。

可是，这里有一个问题，就是，若是班长请假了，用状态模式的道理讲，就是其余学生都请不了假了，也就是若是状态模式中任何一环缺失的话，这个事件都没法进行下去，怎么办？

这就须要咱们的职责链模式。

结构图：

代码实现：

 

<pre name="code" class="html">// Chain of Responsibility pattern -- Structural example
using System;

// "Handler"
abstract class Handler
{
  // Fields
  protected Handler successor;

  // Methods
  public void SetSuccessor( Handler successor )
  {
    this.successor = successor;
  }
  abstract public void HandleRequest( int request );
}

// "ConcreteHandler1"
class ConcreteHandler1 : Handler
{
  // Methods
  override public void HandleRequest( int request )
  {
    if( request >= 0 && request < 10 )
      Console.WriteLine("{0} handled request {1}",
        this, request );
    else
      if( successor != null )
      successor.HandleRequest( request );
  }
}

// "ConcreteHandler2"
class ConcreteHandler2 : Handler
{
  // Methods
  override public void HandleRequest( int request )
  {
    if( request >= 10 && request < 20 )
      Console.WriteLine("{0} handled request {1}",
        this, request );
    else
      if( successor != null )
      successor.HandleRequest( request );
  }
}

// "ConcreteHandler3"
class ConcreteHandler3 : Handler
{
  // Methods
  override public void HandleRequest( int request )
  {
    if( request >= 20 && request < 30 )
      Console.WriteLine("{0} handled request {1}",
        this, request );
    else
      if( successor != null )
      successor.HandleRequest( request );
  }
}

/**//// <summary>
/// Client test
/// </summary>
public class Client
{
  public static void Main( string[] args )
  {
    // Setup Chain of Responsibility
    Handler h1 = new ConcreteHandler1();
    Handler h2 = new ConcreteHandler2();
    Handler h3 = new ConcreteHandler3();
    h1.SetSuccessor(h2);
    h2.SetSuccessor(h3);

    // Generate and process request
    int[] requests = { 2, 5, 14, 22, 18, 3, 27, 20 };

    foreach( int request in requests )
      h1.HandleRequest( request );

  }
}