设计模式 ——— 状态模式

STATE(状态) ———— 对象行为型模式

意图

允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

状态和行为

所谓对象的状态,通常指的就是对象实例的属性的值;而行为指的就是对象的功能,再具体点说,行为多半可以对应到方法上。 状态模式的功能就是分离状态的行为,通过维护状态的变化,来调用不同的状态对应的不同的功能。 也就是说,状态和行为是相关联的,它们的关系可以描述为:状态决定行为。 由于状态是在运行期被改变的,因此行为也会在运行期,根据状态的改变而改变,看起来,同一个对象,在不同的运行时刻,行为是不一样的,就像是类被修改了一样。

行为的平行性

注意是平行性而不是平等性。所谓平行性指的是各个状态的行为所处的层次是一样的,是根据不同的状态来决定到底走平行线的哪一条,行为是不同的,当然对应的实现也是不同的,相互之间是不可替换的。如图所示:

而平等性强调的是可替换性,大家是同一行为的不同描述或实现,因此在同一个行为发生的时候,可以根据条件来挑选任意一个实现来进行相应的处理。如图所示:

大家可能会发现状态模式的结构和策略模式的结构完全一样,但是,它们的目的、实现、本质都是完全不一样的。这个行为之间的特性也是状态模式和策略模式一个很重要的区别,状态模式的行为是平行性的,不可相互替换的;而策略模式的行为是平等性的,是可以相互替换的

适用性

在下面的两种情况下均可使用State模式: ① 一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为。 ② 一个操作中含有庞大的多分支的条件语句,且这些分支依赖于该对象的状态。这个状态通常用一个或多个枚举常量表示。通常,有多个操作包含这一相同的条件结构。State模式将每一个条件分支放入一个独立的类中。这使得你可以根据对象自身的情况将对象的状态作为一个对象,这一对象可以不依赖于其他对象而独立变化。

结构

状态模式结构图.png

  • Context (上下文环境) 定义客户感兴趣的接口 维护一个ConcreteState子类的实例,这个实例定义当前状态。
  • State (状态) 定义一个接口以封装与Context的一个特定状态相关的行为。
  • ConcreteState subclasses (具体状态子类) 每一子类实现一个与Context的一个状态相关的行为。

协作

  • Context将与状态相关的请求委托给当前的ConcreteState对象处理。
  • Context可将自身作为一个参数传递给处理该请求的状态对象。这使得状态对象在必要时可访问Context。
  • Context是客户使用的主要接口。客户可用状态对象来配置一个Context,一旦一个Context配置完毕,它的客户不再需要直接与状态对象打交道。
  • Context或ConcreteState子类都可以决定哪个状态是另外哪一个的后续者,以及是在何种条件下进行状态转换。
状态维护和转换控制

所谓状态的维护,指的就是维护状态的数据,就是给状态设置不同的状态值;而状态的转换,指的就是根据状态的变化来选择不同的状态处理对象。在状态模式中,通常有两个地方可以进行状态的维护和转换控制。 一个就是在上下文(Context)当中,因为状态本身通常被实现为上下文对象的状态,因此可以在上下文里面进行状态维护,当然也就可以控制状态的转换了。 另外一个地方就是在状态的处理类(ConcreteState)里面,当每个状态处理对象处理完自身状态所对应的功能后,可以根据需要指定后继的状态,以便让应用能正确处理后续的请求。

状态模式的优缺点

优点

① 简化应用逻辑控制 状态模式使用单独的类来封装一个状态的处理。如果把一个大的程序控制分成很多小块,每块定义一个状态来代表,那么就可以把这些逻辑控制的代码分散到很多单独的状态类当中去,这样就把着眼点从执行状态提高到整个对象的状态,使得代码结构化和意图更清晰,从而简化应用的逻辑控制。 对于依赖于状态的if-else,理论上来讲,也可以改变成应用状态模式来实现,把每个if或else块定义一个状态来代表,那么就可以把块内的功能代码移动到状态处理类去了,从而减少if-else,避免出现巨大的条件语句。

② 更好的分离状态和行为 状态模式通过设置所有状态类的公共接口,把状态和状态对应的行为分离开来,把所有与一个特定的状态相关的行为都放入一个对象中,使得应用程序在控制的时候,只需要关心状态的切换,而不用关心这个状态对应的真正处理。

③ 更好的扩展性 引入了状态处理的公共接口后,使得扩展新的状态变得非常容易,只需要新增加一个实现状态处理的公共接口的实现类,然后在进行状态维护的地方,设置状态变化到这个新的状态即可。

④ 显式化进行状态转换 状态模式为不同的状态引入独立的对象,使得状态的转换变得更加明确。而且状态对象可以保证上下文不会发生内部状态不一致的情况,因为上下文中只有一个变量来记录状态对象,只要为这一个变量赋值就可以了。

缺点

① 引入太多的状态类 状态模式也有一个很明显的缺点,一个状态对应一个状态处理类,会使得程序引入太多的状态类,使程序变得杂乱。

示例

Context类:

public class GumballMachine {
   State soldOutState;
   State noQuarterState;
   State hasQuarterState;
   State soldState;
   State state = soldOutState;
   int count = 0;
   public GumballMachine(int numberGumballs) {
      soldOutState = new SoldOutState(this);
      noQuarterState = new NoQuarterState(this);
      hasQuarterState = new HasQuarterState(this);
      soldState = new SoldState(this);

      this.count = numberGumballs;
      if (numberGumballs > 0) {
         state = noQuarterState;
      }
   }
   public void insertQuarter() {
      state.insertQuarter();
   }
   public void ejectQuarter() {
      state.ejectQuarter();
   }
   public void turnCrank() {
      state.turnCrank();
      state.dispense();
   }

   void setState(State state) {
      this.state = state;
   }
   void releaseBall() {
      System.out.println("A gumball comes rolling out the slot...");
      if (count != 0) {
         count = count - 1;
      }
   }
   int getCount() {
      return count;
   }
   void refill(int count) {
      this.count = count;
      state = noQuarterState;
   }

    public State getState() {
        return state;
    }

    public State getSoldOutState() {
        return soldOutState;
    }

    public State getNoQuarterState() {
        return noQuarterState;
    }

    public State getHasQuarterState() {
        return hasQuarterState;
    }

    public State getSoldState() {
        return soldState;
    }
   public String toString() {
      StringBuffer result = new StringBuffer();
      result.append("\nMighty Gumball, Inc.");
      result.append("\nJava-enabled Standing Gumball Model #2004");
      result.append("\nInventory: " + count + " gumball");
      if (count != 1) {
         result.append("s");
      }
      result.append("\n");
      result.append("Machine is " + state + "\n");
      return result.toString();
   }
}

State接口:

public interface State {
   public void insertQuarter();
   public void ejectQuarter();
   public void turnCrank();
   public void dispense();
}

ConcreteState 子类:

public class HasQuarterState implements State {
   GumballMachine gumballMachine;
   public HasQuarterState(GumballMachine gumballMachine) {
      this.gumballMachine = gumballMachine;
   }
 
   public void insertQuarter() {
      System.out.println("You can't insert another quarter");
   }
   public void ejectQuarter() {
      System.out.println("Quarter returned");
      gumballMachine.setState(gumballMachine.getNoQuarterState());
   }
   public void turnCrank() {
      System.out.println("You turned...");
      gumballMachine.setState(gumballMachine.getSoldState());
   }

    public void dispense() {
        System.out.println("No gumball dispensed");
    }
   public String toString() {
      return "waiting for turn of crank";
   }
}
public class NoQuarterState implements State {
    GumballMachine gumballMachine;
    public NoQuarterState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }
   public void insertQuarter() {
      System.out.println("You inserted a quarter");
      gumballMachine.setState(gumballMachine.getHasQuarterState());
   }
   public void ejectQuarter() {
      System.out.println("You haven't inserted a quarter");
   }
   public void turnCrank() {
      System.out.println("You turned, but there's no quarter");
    }
   public void dispense() {
      System.out.println("You need to pay first");
   }
   public String toString() {
      return "waiting for quarter";
   }
}
public class SoldOutState implements State {
    GumballMachine gumballMachine;
    public SoldOutState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }
   public void insertQuarter() {
      System.out.println("You can't insert a quarter, the machine is sold out");
   }
   public void ejectQuarter() {
      System.out.println("You can't eject, you haven't inserted a quarter yet");
   }
   public void turnCrank() {
      System.out.println("You turned, but there are no gumballs");
   }
   public void dispense() {
      System.out.println("No gumball dispensed");
   }
   public String toString() {
      return "sold out";
   }
}
public class SoldState implements State {
    GumballMachine gumballMachine;
    public SoldState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }
      
   public void insertQuarter() {
      System.out.println("Please wait, we're already giving you a gumball");
   }
   public void ejectQuarter() {
      System.out.println("Sorry, you already turned the crank");
   }
   public void turnCrank() {
      System.out.println("Turning twice doesn't get you another gumball!");
   }
   public void dispense() {
      gumballMachine.releaseBall();
      if (gumballMachine.getCount() > 0) {
         gumballMachine.setState(gumballMachine.getNoQuarterState());
      } else {
         System.out.println("Oops, out of gumballs!");
         gumballMachine.setState(gumballMachine.getSoldOutState());
      }
   }
   public String toString() {
      return "dispensing a gumball";
   }
}

客户测试:

public class GumballMachineTestDrive {

   public static void main(String[] args) {
      GumballMachine gumballMachine = new GumballMachine(5);

      System.out.println(gumballMachine);

      gumballMachine.insertQuarter();
      gumballMachine.turnCrank();

      System.out.println(gumballMachine);

      gumballMachine.insertQuarter();
      gumballMachine.turnCrank();
      gumballMachine.insertQuarter();
      gumballMachine.turnCrank();

      System.out.println(gumballMachine);
   }
}
参考

《Head First 设计模式》 《设计模式:可复用面向对象软件的基础》 《研磨设计模式》

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏更流畅、简洁的软件开发方式

细分主键

  主键本身是很简单的,但是围绕他产生的故事就不是那么简单了。 1、 管理 这个是最重要的,没有规矩不成方圆,主键要如何管理一定要实现确定好了,甚至有必要为此写...

1836
来自专栏枕边书

请求合并哪家强

工作中,我们常见的请求模型都是请求-应答式,即一次请求中,服务给请求分配一个独立的线程,一块独立的内存空间,所有的操作都是独立的,包括资源和系统运算。我们也知道...

632
来自专栏飞雪无情的博客

Go语言实战笔记(二十七)| Go unsafe Pointer

Go语言在设计的时候,为了编写方便、效率高以及降低复杂度,被设计成为一门强类型的静态语言。强类型意味着一旦定义了,它的类型就不能改变了;静态意味着类型检查在运行...

503
来自专栏CDA数据分析师

Python 异常处理完整指南

年前我写了一篇文章 Python classic, static, class and abstract methods,现在似乎到了更新的时候,今天我想来剖析...

21810
来自专栏微信公众号:Java团长

《深入理解Java虚拟机》笔记

也就是说,我们完全可以做一个工具,从一个文件中读入指令,然后将这些指令运行起来。上面代码中“编好的机器指令”当然指的是能在CPU上运行的,如果这里我还实现了一个...

461
来自专栏光变

Java编程风格

Java编程的风格介绍,主要参考乐google的java code style。对模糊部分作出了明确的选择。

772
来自专栏向治洪

ES7和ES8新特性介绍

概述 JavaScript,作为一门处于高速发展期的开发语言,正在变的越来越完善、稳定。我们必须拥抱这些变化,并且我们需要把ES8加入到我们的技术栈中。 ECM...

4176
来自专栏程序员互动联盟

【专业技术】如何写出优美的C 代码?

面向对象的语言更接近人的思维方式,而且在很大程度上降低了代码的复杂性,同时提高了代码的可读性和可维护性,传统的 C 代码同样可以设计出比较易读,易维护,复杂度较...

3259
来自专栏郭霖

Android最佳性能实践(三)——高性能编码优化

在前两篇文章当中,我们主要学习了Android内存方面的相关知识,包括如何合理地使用内存,以及当发生内存泄露时如何定位出问题的原因。那么关于内存的知识就讨论到这...

19010
来自专栏向治洪

ES7、ES8新特性

概述 JavaScript,作为一门处于高速发展期的开发语言,正在变的越来越完善、稳定。我们必须拥抱这些变化,并且我们需要把ES8加入到我们的技术栈中。 E...

3025

扫码关注云+社区