23种设计模式学习记录之解释器模式_vue 解释器模式-优快云博客

本文链接：https://blog.youkuaiyun.com/lx9876lx/article/details/106749007

本文所有案例代码

码云：https://gitee.com/helloworld6379/designPattern
Github：Github地址

设计模式概述

1 设计模式是程序员在面对同类软件工程设计问题所总结出来的有用的经验，模式不是代码，而是某类问题的通
用解决方案，设计模式（Design pattern）代表了最佳的实践。这些解决方案是众多软件开发人员经过相当长的
一段时间的试验和错误总结出来的。
2 设计模式的本质提高软件的维护性，通用性和扩展性，并降低软件的复杂度。
3 设计模式并不局限于某种语言，java，php，c++ 都有设计模式.

设计模式类型
设计模式分为三种类型，共 23 种
1 创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。
2 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
3 行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter 模式）、状态模式、策略模式、职责链模式(责任链模式)。

简单介绍

意图：给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。
何时使用：如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。
应用实例：编译器、运算表达式计算。
优点： 1、可扩展性比较好，灵活。 2、增加了新的解释表达式的方式。 3、易于实现简单文法。
缺点： 1、可利用场景比较少。 2、对于复杂的文法比较难维护。 3、解释器模式会引起类膨胀。
使用场景： 1、可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。 2、一些重复出现的问题可以用一种简单的语言来进行表达。 3、一个简单语法需要解释的场景。
注意事项：可利用场景比较少，JAVA 中如果碰到可以用 expression4J 代替。

代码实现

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

UML图：
在这里插入图片描述

package com.struggle.pattern.interpreter;

import java.util.HashMap;

/**
 * @Description 抽象类表达式，通过 HashMap 键值对，获取到变量的值
 * @Author LiuXing
 * @Date 2020/06/14 14:26
 */
public abstract class Expression {

    //a + b - c
    //解释公式和数值, key就是公式(表达式) 参数[a,b,c], value就是就是具体值
    //HashMap {a=10, b=20}
    public abstract int interpreter(HashMap<String, Integer> var);
}

package com.struggle.pattern.interpreter;

import java.util.HashMap;

/**
 * @Description 抽象运算符号解析器
 * @Author LiuXing
 * @Date 2020/06/14 14:28
 */
public 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(HashMap<String, Integer> var) {
        return 0;
    }
}

package com.struggle.pattern.interpreter;

import java.util.HashMap;

/**
 * @Description 变量解释器
 * @Author LiuXing
 * @Date 2020/06/14 15:05
 */
public class VarExpression extends Expression {
    private String key; // key=a,key=b,key=c

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

    //var 就是{a=10, b=20}
    //interpreter 根据 变量名称，返回对应值
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return var.get(this.key);
    }
}

package com.struggle.pattern.interpreter;

import java.util.HashMap;

/**
 * @Description 加法解释器
 * @Author LiuXing
 * @Date 2020/06/14 15:06
 */
public class AddExpression extends SymbolExpression {

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

    //var是 {a=10,b=20}..
    public int interpreter(HashMap<String, Integer> var) {
        //super.left.interpreter(var) ： 10
        //super.right.interpreter(var): 20
        return super.left.interpreter(var) + super.right.interpreter(var);
    }

}

package com.struggle.pattern.interpreter;

import java.util.HashMap;

/**
 * @Description 减法解释器
 * @Author LiuXing
 * @Date 2020/06/14 15:06
 */
public class SubExpression extends SymbolExpression {

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

    //求出 left 和 right 表达式相减后的结果
    public int interpreter(HashMap<String, Integer> var) {
        return super.left.interpreter(var) - super.right.interpreter(var);
    }
}

package com.struggle.pattern.interpreter;

import java.util.HashMap;
import java.util.Stack;

/**
 * @Description
 * @Author LiuXing
 * @Date 2020/06/14 15:07
 */
public class Calculator {

    private Expression expression;

    public Calculator(String expStr) { // expStr = a+b
        //保险运算先后顺序
        Stack<Expression> stack = new Stack<>();
        //把表达式拆分成字符数组
        char[] charArray = expStr.toCharArray();// [a, +, b]
        Expression left = null;
        Expression right = null;

        for (int i = 0; i < charArray.length; i++) {
            switch (charArray[i]) {
                case '+': //
                    left = stack.pop();// 从 stack 取出 left => "a"
                    right = new VarExpression(String.valueOf(charArray[++i]));// 取出右表达式 "b"
                    stack.push(new AddExpression(left, right));// 然后根据得到 left 和 right 构建 AddExpresson 加入 stack
                    break;
                case '-':
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new SubExpression(left, right));
                    break;
                default:
                    //如果是一个数字就创建要给 VarExpression 对象，并 push 到 stack
                    stack.push(new VarExpression(String.valueOf(charArray[i])));
                    break;
            }
        }
        //遍历完整个charArray数组后，stack就得到最后 Expression，类似二叉树的数据结构
        this.expression = stack.pop();

    }

    public int run(HashMap<String, Integer> var) {
        //传递给 expression 的 interpreter 进行解释执行
        return this.expression.interpreter(var);
    }
    
}

package com.struggle.pattern.interpreter;

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

/**
 * @Description
 * @Author LiuXing
 * @Date 2020/06/14 15:11
 */
public class InterpreterTest {

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

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

    }

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

请输入表达式：a+b-c
请输入a的值：5
请输入b的值：8
请输入c的值：3
运算结果：a+b-c=10