状态模式与责任链模式

一、状态模式

状态模式定义：当一个对象的内在状态改变时允许其改变行为，这个对象看起来像是改变了其类。也就是说类中的状态改变了，再调用类的方法得到的结果会有所不同

状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时，把状态的判断逻辑转移到表示不同状态的一系列类当中，状态之间的转换在各个状态类中，可以把复杂的逻辑简化。

State抽象状态类：

public abstract class State{

  public abstract void handle(Context context);
  
}

Context类，维护了一个State类型的对象，这个对象就是当前的状态：

public class Context{

  private State state;
  // 状态切换的参照
  private int hour；
  
  public Context(){
    // 状态初始化为ConcreteStateA
    this.state = new ConcreteStateA();
  }

  public void setState(State state){
    this.state = state;
    
    System.out.println("当前状态：" + state.getClass().getClassName());
  }

  public State getState(){
    return this.state;
  }    

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

ConcreteState具体状态类：

public ConcreteStateA{

  @Override
  public void handle(Context context){
    if(context.getHour() < 12){
      System.out.println("状态A");
    } else {
    // 切换到状态B
    context.setState(new ConcreteStateB());
    context.request();
    }
  }
  
}

public ConcreteStateB{

  @Override
  public void handle(Context context){
    if(context.getHour() >= 12){
      System.out.println("状态B");
    } else {
    // 切换到状态A
    context.setState(new ConcreteStateA());
    context.request();
    }
  }
  
}

效果测试类：

public class Test{
   public static void main(String[] args) {
        Context context = new Context();
        context.setHour(19);
        context.request();
        context.setHour(9);
        context.request();
    }
}

输出：
状态B
状态A

二、责任链模式

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

Handler类，请求处理抽象类：

public abstract class Handler {
    /** 责任链中的下一个处理者 */
    protected Handler successor;

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    /** 处理请求的抽象方法 */
    public abstract void handle(int request);
}

ConcreteHandler，具体请求处理类

public class ConcreteHandlerA extends Handler{
    @Override
    public void handle(int request) {
        if(request >= 0 && request < 10){
            System.out.println("ConcreteHandlerA处理请求 " + request);
        } else if(successor != null){
            // 不属于本处理器处理，将请求传递给下一个处理器处理
            successor.handle(request);
        }
    }
}

public class ConcreteHandlerB  extends Handler{
    @Override
    public void handle(int request) {
        if(request >= 10 && request < 20){
            System.out.println("ConcreteHandlerB处理请求 " + request);
        } else if(successor != null){
            // 不属于本处理器处理，将请求传递给下一个处理器处理
            successor.handle(request);
        }
    }
}

public class ConcreteHandlerC extends Handler{
    @Override
    public void handle(int request) {
        if(request >= 20){
            System.out.println("ConcreteHandlerC处理请求 " + request);
        } else if(successor != null){
            // 不属于本处理器处理，将请求传递给下一个处理器处理
            successor.handle(request);
        }
    }
}

ResponsibilityLinkTest，效果演示测试类

public class ResponsibilityLinkTest {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        Handler handlerC = new ConcreteHandlerC();

        // 将请求处理对象形成链
        handlerA.setSuccessor(handlerB);
        handlerB.setSuccessor(handlerC);

        handlerA.handle(12);
        handlerA.handle(222);
    }
}

输出：
ConcreteHandlerB处理请求 12
ConcreteHandlerC处理请求 222

三、状态模式与责任链模式对比

状态模式与责任链模式都存在请求的传递处理，不同的是状态模式通过状态切换来使不同的状态处理类处理请求，而责任链模式直接传递给下一个请求处理类。
状态类中除明确自己在某个状态下的操作外，还要明确如何切换到其他状态