Java 设计模式--解释器模式

本设计模式资料源于慕课网,讲师:Geely 《Java设计模式精讲 Debug方式+内存分析》，本人作为自己手打整理作为学习的归纳总结。

一，模式介绍

1，定义和类型

• 定义：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中句子
• 为了解释一种语言，而为语言创建的解释器
• 类型：行为型

2，适用场景

• 某个特定类型问题发生频率足够高

3，优点

• 语法由很多类表示，容易改变及扩展此“语言”

4，缺点

• 当语法规则数目太多时，增加了系统复杂度

5，相关设计模式

• 解释器模式和适配器模式

二，代码演示

• 业务场景
  将一段含有加减乘除的字符串计算后进行输出
  首先是测试类

package com.try1.design.behavioral.interpreter;

public class Test {
    public static void main(String[] args) {
        String geelyInputStr="6 100 11 + *";
        GeelyExpressionParser expressionParser=new GeelyExpressionParser();
        int result=expressionParser.parse(geelyInputStr);
        System.out.println("解释器计算结果："+result);
    }
}

第一个栈处理类

package com.try1.design.behavioral.interpreter;

import java.util.Stack;

public class GeelyExpressionParser {
    private Stack<Interpreter> stack= new Stack<>();
    public int parse(String str){
        String[] strItemArray=str.split(" ");
        for (String symbol:strItemArray){
            if (!OperatorUtil.isOperator(symbol)){
                Interpreter numberExpression=new NumberInterpreter(symbol);
                stack.push(numberExpression);
                System.out.println(String.format("入栈，%d",numberExpression.interpret()));
            }else {
                Interpreter firstExpression=stack.pop();
                Interpreter secondExpression=stack.pop();
                System.out.println(String.format("出栈，%d,%d",firstExpression.interpret(),secondExpression.interpret()));
                Interpreter operator=OperatorUtil.getExpressionObject(firstExpression,secondExpression,symbol);
                System.out.println(String.format("应用运算符：%s",operator));
                int result=operator.interpret();
                NumberInterpreter resultExpression=new NumberInterpreter(result);
                stack.push(resultExpression);
                System.out.println(String.format("阶段结果入栈，%d",resultExpression.interpret()));
            }
        }
        int result=stack.pop().interpret();
        return result;
    }
}

上面这个类的主要作用是集合各种工具类，首先将字符串分割，再来是判断是否是运算符，不是则将其压入堆栈，是运算符则，弹出两个数进行对应的运算。
下面给出对应的工具类
判断类

package com.try1.design.behavioral.interpreter;

public class OperatorUtil {
    public static boolean isOperator(String symbol){
        return (symbol.equals("+") || symbol.equals("*"));
    }
    public static Interpreter getExpressionObject(Interpreter firstExpression,Interpreter secondExpression,String symbol){
        if (symbol.equals("+")){
            return new AddInterpreter(firstExpression,secondExpression);
        }else if(symbol.equals("*")){
            return new MultiInterpreter(firstExpression,secondExpression);
        }
        return null;
    }
}

关联类对应接口

package com.try1.design.behavioral.interpreter;

public interface Interpreter {
    int interpret();
}

非运算符转化类

package com.try1.design.behavioral.interpreter;

public class NumberInterpreter implements Interpreter {
    private int number;

    public NumberInterpreter(int number) {
        this.number = number;
    }

    public NumberInterpreter(String number) {
        this.number = Integer.parseInt(number);
    }

    @Override
    public int interpret() {
        return this.number;
    }
}

乘法处理类

package com.try1.design.behavioral.interpreter;

public class MultiInterpreter implements Interpreter{
    private Interpreter firstExpression,secondExprssion;

    public MultiInterpreter(Interpreter firstExpression, Interpreter secondExprssion) {
        this.firstExpression = firstExpression;
        this.secondExprssion = secondExprssion;
    }

    @Override
    public int interpret() {
        return this.firstExpression.interpret()*this.secondExprssion.interpret();
    }

    @Override
    public String toString() {
        return "*";
    }
}

加法处理类

package com.try1.design.behavioral.interpreter;

public class AddInterpreter implements Interpreter {
    private Interpreter firstExpression,secondExprssion;

    public AddInterpreter(Interpreter firstExpression, Interpreter secondExprssion) {
        this.firstExpression = firstExpression;
        this.secondExprssion = secondExprssion;
    }

    @Override
    public int interpret() {
        return this.firstExpression.interpret()+this.secondExprssion.interpret();
    }

    @Override
    public String toString() {
        return "+";
    }
}

运行截图

下面是 spring 自带的一个解释器

package com.try1.design.behavioral.interpreter;

public class SpringTest {
    public static void main(String[] args) {
//        org.springframework.expression.ExpressionParser parser=new SpelExpressionParser();
//        Expression expression=parser.parseExpression("100 * 2 + 400 * 1 + 66");
//        int result=(Integer)expression.getValue();
//        System.out.println(result);
    }
}

三，总结

• 其实总的来说，该设计模式只让我想到了之前算法课上学到的跟这个很类似的，一个实现计算器的代码格式，这个里面则是将每个的返回值进行了，统一和规整。
• 解释器应该能应用于某个大型的处理步骤中。