解释器模式与状态模式

解释器模式与状态模式

参考教程：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
  1. 传统方法

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

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

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

  1. 解释器模式

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

  1. 代码实现
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;
    }
}
  1. 小结

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

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

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

状态模式

  1. 案例

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

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

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

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

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

1-1593219844922.png
  1. 状态模式

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

  1. 代码实现
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();
        }
    }
}
  1. 小结

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

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

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

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

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

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 213,047评论 6赞 492
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,807评论 3赞 386
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 158,501评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,839评论 1赞 285
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,951评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,117评论 1赞 291
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,188评论 3赞 412
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,929评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,372评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,679评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,837评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,536评论 4赞 335
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,168评论 3赞 317
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,886评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,129评论 1赞 267
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,665评论 2赞 362
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,739评论 2赞 351