【设计模式（20）】行为型模式之状态模式

个人学习笔记分享，当前能力有限，请勿贬低，菜鸟互学，大佬绕道

如有勘误，欢迎指出和讨论，本文后期也会进行修正和补充

人都有喜怒哀乐，在不同的情绪下，我们可能会作出不同的行为，进而影响外界事物；而外界事物也可能影响我们的情绪，导致我们作出不同的行为（完美闭环）

开发中的对象，有时候也会根据不同的情况作出不同的行为，而对象与外部事件交互的时候，也可能改变自身的状态，进而行为也发生改变

对于有多种状态的对象，传统的解决方案是枚举所有的情况，使用条件判断语句if-else或者switch-case来判断，但对于复杂的状态判断，则会显得过于臃肿和混乱。而且每次新增状态都需要新增一个判断，扩展性差

状态模式就是为了解决这种问题而出现的，通过将状态相关的判断逻辑提取出来，使用不同的类进行表示，根据不同的状态选择相应的类来进行处理。

1.介绍

适用目的：允许对象在内部状态发生改变时改变它的行为

主要解决：对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为。

何时使用：代码中包含大量与对象状态有关的条件语句。

如何解决：将各种具体的状态类抽象出来，单独成为类。

关键代码：定义统一的接口，根据不同的状态进行不同实现。

应用实例：系统和应用的低负载/高负载/超载状态；安装程序的下一步；

优点：

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

缺点：

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

使用场景：

• 行为随状态改变而改变的场景。
• 条件、分支语句的代替者。

2.结构

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

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

[图片上传失败...(image-d9a5a6-1625105929718)]

3.步骤

1. 创建环境类

   class Context {
       private State state;
   
       public Context(State state) {
           this.state = state;
       }
   
       public State getState() {
           return state;
       }
   
       public void setState(State state) {
           this.state = state;
       }
   
       public void handle() {
           state.handle(this);
       }
   }
   

2. 创建抽象状态

   interface State {
       void handle(Context context);
   }
   

3. 创建具体状态

   class StateA implements State {
       @Override
       public void handle(Context context) {
           System.out.println("change stateA to stateB");
           // 状态变为B
           context.setState(new StateB());
       }
   }
   
   class StateB implements State {
       @Override
       public void handle(Context context) {
           System.out.println("change stateB to stateC");
           // 状态变为C
           context.setState(new StateC());
       }
   }
   
   
   class StateC implements State {
       @Override
       public void handle(Context context) {
           System.out.println("change stateC to stateA");
           // 状态变为C
           context.setState(new StateA());
       }
   }
   

测试代码

public class StateTest {
    public static void main(String[] args) {
        Context context = new Context(new StateA());    // 创建环境，初始状态为A
        context.handle();   // 第1次变更，A变为B
        context.handle();   // 第2次变更，B变为C
        context.handle();   // 第3次变更，C变为A
        context.handle();   // 第4次变更，A变为B
    }
}

运行结果

[图片上传失败...(image-3513da-1625105929718)]

4.实例

模拟场景如下

• 分数包括三种评级
  • 不及格：小于60分
  • 及格：大于等于60且小于90
  • 优秀：大于等于90
• 对分数进行加减，获取当前的分数和评级

代码如下

package com.company.designPattern.state;

import java.util.Scanner;

public class ScoreStateTest {
    public static void main(String[] args) {
        ScoreContext account = new ScoreContext();
        Scanner input = new Scanner(System.in);
        System.out.println("学生成绩状态测试：");
        while (true) {
            System.out.print("请输入分数变化：");
            int num = input.nextInt();
            account.add(num);
        }
    }
}

//环境类
class ScoreContext {
    private AbstractState state;

    ScoreContext() {
        state = new LowState(this);
    }

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

    public AbstractState getState() {
        return state;
    }

    public void add(int score) {
        state.addScore(score);
    }
}

//抽象状态类
abstract class AbstractState {
    protected ScoreContext context;  //环境
    protected String stateName; //状态名
    protected int score; //分数

    public abstract void checkState(); //检查当前状态

    public void addScore(int x) {
        score += x;
        System.out.print("加上：" + x + "分，\t当前分数：" + score);
        checkState();
        System.out.println("分，\t当前状态：" + context.getState().stateName);
    }
}

//具体状态类：不及格
class LowState extends AbstractState {
    public LowState(ScoreContext h) {
        context = h;
        stateName = "不及格";
        score = 0;
    }

    public LowState(AbstractState state) {
        context = state.context;
        stateName = "不及格";
        score = state.score;
    }

    public void checkState() {
        if (score >= 90) {
            context.setState(new HighState(this));
        } else if (score >= 60) {
            context.setState(new MiddleState(this));
        }
    }
}

//具体状态类：中等
class MiddleState extends AbstractState {
    public MiddleState(AbstractState state) {
        context = state.context;
        stateName = "及格";
        score = state.score;
    }

    public void checkState() {
        if (score < 60) {
            context.setState(new LowState(this));
        } else if (score >= 90) {
            context.setState(new HighState(this));
        }
    }
}

//具体状态类：优秀
class HighState extends AbstractState {
    public HighState(AbstractState state) {
        context = state.context;
        stateName = "优秀";
        score = state.score;
    }

    public void checkState() {
        if (score < 60) {
            context.setState(new LowState(this));
        } else if (score < 90) {
            context.setState(new MiddleState(this));
        }
    }
}

运行结果

image-20210630102016702

后记

感觉是个很有意思的东西，非常巧妙的达到了多状态和行为切换的目的，同时保证了高性能和低耦合

作者：Echo_Ye

WX：Echo_YeZ

Email ：[email protected]

个人站点：在搭了在搭了。。。（右键 - 新建文件夹）