解释器模式与状态模式

解释器模式与状态模式

参考教程：https://www.bilibili.com/video/BV1G4411c7N4
代码实现 Github：https://github.com/yaokuku123/pattern

---

解释器模式

1. 案例

通过解释器模式来实现四则运算，如计算a+b-c的值

具体要求：

1. 先输入表达式的形式，比如 a+b+c-d+e, 要求表达式的字母不能重复

2. 在分别输入a ,b, c, d, e 的值

3. 最后求出结果：如图

1-1593217068426.png

2. 传统方法

1. 编写一个方法，接收表达式的形式，然后根据用户输入的数值进行解析，得到结果

2. 问题分析：如果加入新的运算符，比如 * / ( 等等，不利于扩展，另外让一个方法来解析会造成程序结构混乱，不够清晰.

3. 解决方案：可以考虑使用解释器模式， 即： 表达式 -> 解释器(可以有多种) -> 结果

3. 解释器模式

解释：是指给定一个语言(表达式)，定义它的文法 的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子(表达式)。) 这样的例子还有，比如编译器、运算表达式计算、正则表达式、机器人等。

4. 代码实现

2-1593217227165.png

对原理类图的说明-即(解释器模式的角色及职责)

1. Context: 是环境角色,含有解释器之外的全局信息.

2. AbstractExpression: 抽象表达式， 声明一个抽象的解释操作,这个方法为抽象语法树中所有的节点所共享

3. TerminalExpression: 为终结符表达式, 实现与文法中的终结符相关的解释操作

4. NonTermialExpression: 为非终结符表达式，为文法中的非终结符实现解释操作.

5. 说明： 输入Context 和 TerminalExpression 信息通过Client 输入即可

3-1593217324146.png

package com.yqj.pattern.interpreter;


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

class Calculator {
    private Expression expression;

    public Calculator(String expStr) {
        //使用栈结构模拟先后顺序
        Stack<Expression> stack = new Stack<>();
        //表达式拆分为字符数组
        char[] charArray = expStr.toCharArray();
        //定义左右两个Expression
        Expression left = null;
        Expression right = null;
        //遍历每个字符
        for (int i = 0; i < charArray.length; i++) {
            switch (charArray[i]) {
                case '+':
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new AddExpression(left, right));
                    break;
                case '-':
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new SubExpression(left, right));
                    break;
                default:
                    stack.push(new VarExpression(String.valueOf(charArray[i])));
                    break;
            }
        }
        //保存最后stack中剩余的结果
        this.expression = stack.pop();
    }

    public int run(Map<String, Integer> var) {
        //将数据传递给解释器进行递归解析
        return this.expression.interpreter(var);
    }
}

//抽象类表达式，根据不同的具体类做对应不同的处理，但都继承相同的方法，实现递归调用
abstract class Expression {
    //抽象方法，通过该方法可以获得变量的值
    public abstract int interpreter(Map<String, Integer> var);
}

//变量解释器
class VarExpression extends Expression {
    private String key;

    public VarExpression(String key) {
        this.key = key;
    }

    @Override
    public int interpreter(Map<String, Integer> var) {
        return var.get(key);
    }
}

//抽象运算符解析器，每个运算符仅与自己左右两个数字有关，但同时左右两个数字也可能是一个解析器，但都是Expression类型
class SymbolExpression extends Expression {

    protected Expression left;
    protected Expression right;

    public SymbolExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpreter(Map<String, Integer> var) {
        return 0;
    }
}

//加法解释器
class AddExpression extends SymbolExpression {

    public AddExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpreter(Map<String, Integer> var) {
        return super.left.interpreter(var) + super.right.interpreter(var);
    }
}

//减法解释器
class SubExpression extends SymbolExpression {

    public SubExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpreter(Map<String, Integer> var) {
        return super.left.interpreter(var) - super.right.interpreter(var);
    }
}

public class Client {
    public static void main(String[] args) throws IOException {
        String expStr = getExpStr();
        Map<String, Integer> var = getValue(expStr);
        Calculator calculator = new Calculator(expStr);
        System.out.println("运算结果：" + expStr + "=" + calculator.run(var));
    }

    //获取表达式
    public static String getExpStr() throws IOException {
        System.out.println("请输入表达式：");
        return (new BufferedReader(new InputStreamReader(System.in))).readLine();
    }

    //获取值映射
    public static Map<String, Integer> getValue(String expStr) throws IOException {
        Map<String, Integer> map = new HashMap<>();
        for (char ch : expStr.toCharArray()) {
            if (ch != '+' && ch != '-') {
                if (!map.containsKey(String.valueOf(ch))) {
                    System.out.println("请输入" + String.valueOf(ch) + "的值：");
                    String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
                    map.put(String.valueOf(ch), Integer.valueOf(in));
                }
            }
        }
        return map;
    }
}

5. 小结

1. 当有一个语言需要解释执行，可将该语言中的句子表示为一个抽象语法树，就可以考虑使用解释器模式，让程序具有良好的扩展性

2. 应用场景：编译器、运算表达式计算、正则表达式、机器人等

3. 使用解释器可能带来的问题：解释器模式会引起类膨胀、解释器模式采用递归调用方法，将会导致调试非常复杂、效率可能降低.

状态模式

1. 案例

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

1. 假如每参加一次这个活动要扣除用户50积分，中奖概率是10%

2. 奖品数量固定，抽完就不能抽奖

3. 活动有四个状态: 可以抽奖、 不能抽奖、发放奖品和奖品领完

4. 活动的四个状态转换关系图

1-1593219844922.png

2. 状态模式

解释：它主要用来解决对象在多种状态转换时，需要对外输出不同的行为的问题。状态和行为是一一对应的，状态之间可以相互转换。

3. 代码实现

2-1593219935895.png

对原理类图的说明-即(状态模式的角色及职责)

1. Context 类为环境角色, 用于维护State实例,这个实例定义当前状态

2. State 是抽象状态角色,定义一个接口封装与Context 的一个特点接口相关行为

3. ConcreteState 具体的状态角色，每个子类实现一个与Context 的一个状态相关行为

3-1593220033473.png

package com.yqj.pattern.state;

import java.util.Random;

class Activity{
    //当前状态
    private State state = null;
    //奖品数量
    private int count = 0;
    //钱数
    private int money = 0;

    //状态
    private State noRaffleState = new NoRaffleState(this);
    private State canRaffleState = new CanRaffleState(this);
    private State dispenseState = new DispenseState(this);
    private State dispenseOutState = new DispenseOutState(this);

    public Activity(int count, int money) {
        this.state = getNoRaffleState();
        this.count = count;
        this.money = money;
    }

    //扣钱
    public void deduceMoney(){
        state.deduceMoney();
    }

    //抽奖
    public void raffle(){
        if(state.raffle()){
            state.dispensePrize();
        }
    }

    public State getState() {
        return state;
    }

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

    public int getCount() {
        return count;
    }

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

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public State getNoRaffleState() {
        return noRaffleState;
    }

    public State getCanRaffleState() {
        return canRaffleState;
    }

    public State getDispenseState() {
        return dispenseState;
    }

    public State getDispenseOutState() {
        return dispenseOutState;
    }

}


//抽象类，定义各个状态都需要实现的不同行为
abstract class State{
    public abstract void deduceMoney();
    public abstract boolean raffle();
    public abstract void dispensePrize();
}

class NoRaffleState extends State{

    private Activity activity;

    public NoRaffleState(Activity activity) {
        this.activity = activity;
    }

    @Override
    public void deduceMoney() {
        if(activity.getCount()>0){
            int currentMoney = activity.getMoney();
            if(currentMoney - 50 >=0){
                activity.setMoney(currentMoney - 50);
                activity.setState(activity.getCanRaffleState());
                System.out.println("成功扣除50块钱,余额:"+(activity.getMoney()));
            }else {
                System.out.println("余额不足,抽奖结束");
                System.exit(0);
            }
        }else {
            activity.setState(activity.getDispenseOutState());
        }
    }

    @Override
    public boolean raffle() {
        System.out.println("请先扣钱");
        return false;
    }

    @Override
    public void dispensePrize() {
        System.out.println("请先扣钱");
    }
}

class CanRaffleState extends State{

    private Activity activity;

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

    @Override
    public void deduceMoney() {
        System.out.println("已扣钱");
    }

    @Override
    public boolean raffle() {
        System.out.println("正在抽奖");
        Random random = new Random();
        int num = random.nextInt(10);
        if (num == 0){
            System.out.println("抽奖成功");
            activity.setCount(activity.getCount()-1);
            activity.setState(activity.getDispenseState());
            return true;
        }
        System.out.println("很遗憾，没有抽到奖品");
        activity.setState(activity.getNoRaffleState());
        return false;
    }

    @Override
    public void dispensePrize() {
        System.out.println("请先抽奖");
    }
}

class DispenseState extends State{

    private Activity activity;

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

    @Override
    public void deduceMoney() {
        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.getNoRaffleState());
        }else {
            System.out.println("发送奖品，奖品已抽完");
            activity.setState(activity.getDispenseOutState());
        }
    }
}

class DispenseOutState extends State{

    private Activity activity;

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

    @Override
    public void deduceMoney() {
        System.out.println("奖品已抽完，无法扣款");
    }

    @Override
    public boolean raffle() {
        System.out.println("奖品已抽完，无法抽奖");
        return false;
    }

    @Override
    public void dispensePrize() {
        System.out.println("奖品已抽完");
    }
}

public class Client {
    public static void main(String[] args) {
        Activity activity = new Activity(2,500);
        for (int i = 0; i < 30; i++) {
            System.out.println("-----第"+(i+1)+"次抽奖-----");
            //扣钱
            activity.deduceMoney();
            //参与抽奖
            activity.raffle();
        }
    }
}

4. 小结

1. 代码有很强的可读性。状态模式将每个状态的行为封装到对应的一个类中

2. 方便维护。将容易产生问题的if-else语句删除了，如果把每个状态的行为都放到一 个类中，每次调用方法时都要判断当前是什么状态，不但会产出很多if-else语句， 而且容易出错

3. 符合“开闭原则”。容易增删状态

4. 会产生很多类。每个状态都要一个对应的类，当状态过多时会产生很多类，加大维护难度

5. 应用场景：当一个事件或者对象有很多种状态，状态之间会相互转换，对不同的状态要求有不同的行为的时候，可以考虑使用状态模式