Bootstrap

设计模式之状态模式

状态模式

在软件开发过程中，应用程序中的部分对象可能会根据不同的情况做出不同的行为，我们把这种对象称为有状态的对象，而把影响对象行为的一个或多个动态变化的属性称为状态。当有状态的对象与外部事件产生互动时，其内部状态就会发生改变，从而使其行为也发生改变。如人都有高兴和伤心的时候，不同的情绪有不同的行为，当然外界也会影响其情绪变化。

对这种有状态的对象编程，传统的解决方案是：将这些所有可能发生的情况全都考虑到，然后使用 if-else 或 switch-case 语句来做状态判断，再进行不同情况的处理。但是显然这种做法对复杂的状态判断存在天然弊端，条件判断语句会过于臃肿，可读性差，且不具备扩展性，维护难度也大。且增加新的状态时要添加新的 if-else 语句，这违背了“开闭原则”，不利于程序的扩展。

以上问题如果采用“状态模式”就能很好地得到解决。状态模式的解决思想是：当控制一个对象状态转换的条件表达式过于复杂时，把相关“判断逻辑”提取出来，用各个不同的类进行表示，系统处于哪种情况，直接使用相应的状态类对象进行处理，这样能把原来复杂的逻辑判断简单化，消除了 if-else、switch-case 等冗余语句，代码更有层次性，并且具备良好的扩展力。

 

APP 抽奖活动问题

请编写程序完成APP抽奖活动具体要求如下：

  1. 假如每参加一次这个活动要扣除用户50积分，中奖概率是10%
  2. 奖品数量固定，抽完就不能抽奖
  3. 活动有四个状态：可以抽奖、不能抽奖、发放奖品和奖品领完
  4. 活动的四个状态转换关系图
  5. (下图)

 

状态模式基本介绍

基本介绍

  1. 状态模式（StatePattern）：它主要用来解决对象在多种状态转换时，需要对外输出不同的行为的问题。状态和行为是一一对应的，状态之间可以相互转换
  2. 当一个对象的内在状态改变时，允许改变其行为，这个对象看起来像是改变了其类

状态模式是一种对象行为型模式，其主要优点如下：

  1. 结构清晰，状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”
  2. 将状态转换显示化，减少对象间的相互依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖
  3. 状态类职责明确，有利于程序的扩展。通过定义新的子类很容易地增加新的状态和转换

状态模式的主要缺点如下：

  1. 状态模式的使用必然会增加系统的类与对象的个数
  2. 状态模式的结构与实现都较为复杂，如果使用不当会导致程序结构和代码的混乱
  3. 状态模式对开闭原则的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源码，否则无法切换到新增状态，而且修改某个状态类的行为也需要修改对应类的源码

 

状态模式的结构与实现

状态模式把受环境改变的对象行为包装在不同的状态对象里，其意图是让一个对象在其内部状态改变的时候，其行为也随之改变。现在我们来分析其基本结构和实现方法。

1. 模式的结构

状态模式包含以下主要角色：

  1. 环境类（Context）角色：也称为上下文，它定义了客户端需要的接口，内部维护一个当前状态，并负责具体状态的切换
  2. 抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为，可以有一个或多个行为
  3. 具体状态（Concrete State）角色：实现抽象状态所对应的行为，并且在需要的情况下进行状态切换

2. 模式的实现

状态模式的实现代码如下：

public class StatePatternClient {

    public static void main(String[] args) {
        // 创建环境      
        Context context = new Context();
        // 处理请求
        context.Handle();
        context.Handle();
        context.Handle();
        context.Handle();
    }
}


// 环境类
class Context {

    private State state;

    // 定义环境类的初始状态
    public Context() {
        this.state = new ConcreteStateA();
    }

    // 设置新状态
    public void setState(State state) {
        this.state = state;
    }

    // 读取状态
    public State getState() {
        return (state);
    }

    // 对请求做处理
    public void Handle() {
        state.Handle(this);
    }
}


// 抽象状态类
abstract class State {
    public abstract void Handle(Context context);
}


// 具体状态A类
class ConcreteStateA extends State {

    public void Handle(Context context) {
        System.out.println("当前状态是 A.");
        context.setState(new ConcreteStateB());
    }
}


// 具体状态B类
class ConcreteStateB extends State {

    public void Handle(Context context) {
        System.out.println("当前状态是 B.");
        context.setState(new ConcreteStateA());
    }
}

程序运行结果如下：

当前状态是 A.
当前状态是 B.
当前状态是 A.
当前状态是 B.

 

状态模式解决 APP 抽奖问题

  1. 应用实例要求完成 APP 抽奖活动项目，使用状态模式
  2. 思路分析和图解（类图）——定义出一个接口叫状态接口，每个状态都实现它。 ——接口有扣除积分方法、抽奖方法、发放奖品方法
  4. 代码实现
package com.atguigu.state;
import java.util.Random;

/**
 * 可以抽奖的状态
 *
 * @author Administrator
 */
public class CanRaffleState extends State {

    RaffleActivity activity;

    public CanRaffleState(RaffleActivity activity) { 
        this.activity = activity;
    }

    // 已经扣除了积分，不能再扣 
    @Override
    public void deductMoney() {
        System.out.println("已经扣取过了积分"); 
    }

    // 可以抽奖, 抽完奖后，根据实际情况，改成新的状态 
    @Override
    public boolean raffle() {
        System.out.println("正在抽奖，请稍等!"); 
        Random r = new Random();
        int num = r.nextInt(10);
        // 10%中奖机会
        if (num == 0) {
            // 改变活动状态为发放奖品 context 
            activity.setState(activity.getDispenseState()); 
            return true;
        } else { 
            System.out.println("很遗憾没有抽中奖品!"); 
            // 改变状态为不能抽奖 
            activity.setState(activity.getNoRafflleState()); 
            return false;
        } 
    }

    // 不能发放奖品 
    @Override
    public void dispensePrize() {
        System.out.println("没中奖，不能发放奖品"); 
    }
}
package com.atguigu.state;

/**
 * 状态模式测试类
 * 
 * @author Administrator 
 */
public class ClientTest {

    public static void main(String[] args) {
        // 创建活动对象，奖品有 1 个奖品
        RaffleActivity activity = new RaffleActivity(1);
        // 我们连续抽 300 次奖 
        for (int i = 0; i < 30; i++) {
            System.out.println("--------第" + (i + 1) + "次抽奖----------"); 
            // 参加抽奖，第一步点击扣除积分 
            activity.debuctMoney();
            // 第二步抽奖
            activity.raffle(); 
        }
    } 
}
package com.atguigu.state;

/**
 * 奖品发放完毕状态
 * 说明，当我们 activity 改变成 DispenseOutState， 抽奖活动结束 
 * 
 * @author Administrator
 */
public class DispenseOutState extends State {

    // 初始化时传入活动引用 
    RaffleActivity activity;

    public DispenseOutState(RaffleActivity activity) { 
        this.activity = activity;
    }

    @Override
    public void deductMoney() {
        System.out.println("奖品发送完了，请下次再参加"); 
    }

    @Override
    public boolean raffle() {
        System.out.println("奖品发送完了，请下次再参加"); 
        return false;
    }

    @Override
    public void dispensePrize() {
        System.out.println("奖品发送完了，请下次再参加"); 
    }
}
package com.atguigu.state;

/**
 * 发放奖品的状态
 * 
 * @author Administrator 
 */
public class DispenseState extends State {

    // 初始化时传入活动引用，发放奖品后改变其状态 
    RaffleActivity activity;

    public DispenseState(RaffleActivity activity) { 
        this.activity = activity;
    } 

    @Override
    public void deductMoney() {
        System.out.println("不能扣除积分"); 
    }

    @Override
    public boolean raffle() {
        System.out.println("不能抽奖");
        return false; 
    }

    // 发放奖品
    @Override
    public void dispensePrize() {
        if (activity.getCount() > 0) { 
            System.out.println("恭喜中奖了");
            // 改变状态为不能抽奖 
            activity.setState(activity.getNoRafflleState());
        } else {
            System.out.println("很遗憾，奖品发送完了");
            // 改变状态为奖品发送完毕, 后面我们就不可以抽奖         
            activity.setState(activity.getDispensOutState()); 
        }
    }
}
package com.atguigu.state;

/**
 * 不能抽奖状态
 *
 * @author Administrator 
 */
public class NoRaffleState extends State {

    // 初始化时传入活动引用，扣除积分后改变其状态 
    RaffleActivity activity;
    public NoRaffleState(RaffleActivity activity) { 
        this.activity = activity;
    }

    // 当前状态可以扣积分 , 扣除后，将状态设置成可以抽奖状态 
    @Override
    public void deductMoney() {
        System.out.println("扣除 50 积分成功，您可以抽奖了");
        activity.setState(activity.getCanRaffleState()); 
    }

    // 当前状态不能抽奖 
    @Override
    public boolean raffle() {
        System.out.println("扣了积分才能抽奖喔!");
        return false; 
    }

    // 当前状态不能发奖品 
    @Override
    public void dispensePrize() {
        System.out.println("不能发放奖品"); 
    }
}
package com.atguigu.state;

/**
 * 抽奖活动 
 *
 * @author Administrator 
 */
public class RaffleActivity {

    // state 表示活动当前的状态，是变化 
    State state = null;

    // 奖品数量 
    int count = 0;

    // 四个属性，表示四种状态
    State noRafflleState = new NoRaffleState(this); 
    State canRaffleState = new CanRaffleState(this);
    State dispenseState = new DispenseState(this); 
    State dispensOutState = new DispenseOutState(this);

    // 构造器
    // 1. 初始化当前的状态为 noRafflleState(即不能抽奖的状态) 
    // 2. 初始化奖品的数量
    public RaffleActivity( int count) {
        this.state = getNoRafflleState();
        this.count = count; 
    }

    // 扣分, 调用当前状态的 deductMoney 
    public void debuctMoney(){
        state.deductMoney(); 
    }

    // 抽奖
    public void raffle(){
        // 如果当前的状态是抽奖成功
        if (state.raffle()) { 
            //领取奖品
            state.dispensePrize(); 
        }
    }

    public State getState() { 
        return state;
    }

    public void setState(State state) { 
        this.state = state;
    }

    // 这里请大家注意，每领取一次奖品，count-- 
    public int getCount() {
        int curCount = count; 
        count--;
        return curCount; 
    }

    public void setCount(int count) { 
        this.count = count;
    }

    public State getNoRafflleState() { 
        return noRafflleState;
    }

    public void setNoRafflleState(State noRafflleState) { 
        this.noRafflleState = noRafflleState;
    }

    public State getCanRaffleState() { 
        return canRaffleState;
    }

    public void setCanRaffleState(State canRaffleState) { 
        this.canRaffleState = canRaffleState;
    }

    public State getDispenseState() { 
        return dispenseState;
    }

    public void setDispenseState(State dispenseState) { 
        this.dispenseState = dispenseState;
    }

    public State getDispensOutState() { 
        return dispensOutState;
    }

    public void setDispensOutState(State dispensOutState) { 
        this.dispensOutState = dispensOutState;
    } 
}
package com.atguigu.state;

/**
 * 状态抽象类
 *
 * @author Administrator 
 */
public abstract class State {

    // 扣除积分 - 50
    public abstract void deductMoney();

    // 是否抽中奖品
    public abstract boolean raffle();

    // 发放奖品
    public abstract void dispensePrize();
}

 

状态模式的应用场景

通常在以下情况下可以考虑使用状态模式：

  1. 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式
  2. 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时

 

状态模式的扩展

在有些情况下，可能有多个环境对象需要共享一组状态，这时需要引入享元模式，将这些具体状态对象放在集合中供程序共享，其结构图如图 5 所示。

分析：共享状态模式的不同之处是在环境类中增加了一个 HashMap 来保存相关状态，当需要某种状态时可以从中获取，其程序代码如下：

package state;

import java.util.HashMap;

public class FlyweightStatePattern {

    public static void main(String[] args) {
        ShareContext context = new ShareContext(); //创建环境      
        context.Handle(); //处理请求
        context.Handle();
        context.Handle();
        context.Handle();
    }
}


// 环境类
class ShareContext {

    private ShareState state;

    private HashMap<String, ShareState> stateSet = new HashMap<String, ShareState>();

    public ShareContext() {
        state = new ConcreteState1();
        stateSet.put("1", state);
        state = new ConcreteState2();
        stateSet.put("2", state);
        state = getState("1");
    }

    // 设置新状态
    public void setState(ShareState state) {
        this.state = state;
    }

    // 读取状态
    public ShareState getState(String key) {
        ShareState s = (ShareState) stateSet.get(key);
        return s;
    }

    // 对请求做处理
    public void Handle() {
        state.Handle(this);
    }
}


// 抽象状态类
abstract class ShareState {
    public abstract void Handle(ShareContext context);
}


// 具体状态1类
class ConcreteState1 extends ShareState {

    public void Handle(ShareContext context) {
        System.out.println("当前状态是： 状态1");
        context.setState(context.getState("2"));
    }
}


// 具体状态2类
class ConcreteState2 extends ShareState {

    public void Handle(ShareContext context) {
        System.out.println("当前状态是： 状态2");
        context.setState(context.getState("1"));
    }
}

程序运行结果如下：

当前状态是： 状态1
当前状态是： 状态2
当前状态是： 状态1
当前状态是： 状态2

 

拓展

状态模式与责任链模式的区别

状态模式和责任链模式都能消除 if-else 分支过多的问题。但在某些情况下，状态模式中的状态可以理解为责任，那么在这种情况下，两种模式都可以使用。
从定义来看，状态模式强调的是一个对象内在状态的改变，而责任链模式强调的是外部节点对象间的改变。
从代码实现上来看，两者最大的区别就是状态模式的各个状态对象知道自己要进入的下一个状态对象，而责任链模式并不清楚其下一个节点处理对象，因为链式组装由客户端负责。

状态模式与策略模式的区别

状态模式和策略模式的 UML 类图架构几乎完全一样，但两者的应用场景是不一样的。策略模式的多种算法行为择其一都能满足，彼此之间是独立的，用户可自行更换策略算法，而状态模式的各个状态间存在相互关系，彼此之间在一定条件下存在自动切换状态的效果，并且用户无法指定状态，只能设置初始状态。

 

部分引用：http://c.biancheng.net/view/1322.html

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
logistics回归之sklearn中的LogisticRegressionCV
Mysql是怎样运行的之InnoDB介绍
随机事件与随机变量
2. 例-中断（GPIO按键事件）
MDrive RS-422/485通讯线MD-CC400-001,MD-CC402-001
mysql 设置 sql_mode
昇腾CANN环境下Whisper.cpp安装指南
django中entity.save(using=）的使用
ELK7.8部署：Elasticsearch+Logstash+Kibana搭建分布式日志平台
js 定时器的用法
;