解释器模式详解附有代码案例分析

最新推荐文章于 2024-05-03 18:10:14 发布

hyyyya

最新推荐文章于 2024-05-03 18:10:14 发布

阅读量588

点赞数

分类专栏：设计模式文章标签： java 设计模式编程语言

本文链接：https://blog.csdn.net/hyyyya/article/details/109186515

版权

设计模式专栏收录该内容

23 篇文章 5 订阅

订阅专栏

解释器模式

一、解释器模式的概念与角色

（一）、解释器模式的概念

解释器模式是指给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来接受语言中的句子。是一种按照规定的语法进行解析的模式，属于行为型模式。

解释器模式的作用其实与编译器一样，都是将一些固定的语法进行接受，构建出一个接受句子的解释器。简单理解，解释器是一个简单语法分析工具，它可以识别句子语义，分离终结符号和非终结符号，提取出需要的信息，让我们能针对不同的信息做出相应的处理。其核心思想是识别语法，构建解释。

（二）、解释器模式的角色

1、抽象表达式（Expression）：负责定义一个解释方法interpret，交由具体子类进行具体解释。

2、终结符表达式（TerminalExpression）：实现文法中与终结符有关的解释操作。文法中的每一个终结符都有以恶具体终结表达式与之相对应，比如公式R=R1+R2，R1和R2就是终结符。对应的解析R1和R2的解释器就是终结符表达式。通常一个解释器模式中只有一个终结符表达式，但有多个实例，对应不同的终结符（R1，R2）。

3、非终结符表达式（NonterminalExpression）：实现文法中与非终结符有关的解释操作。文法中的每条规则都对应一个非终结符表达式。非终结符表达式一般是文法中的运算符或者其他关键字，比如R=R1+R2，“+”就是非终结符，解析“+”的解释器就是一个非终结符表达式。非终结符表达式根据逻辑的负责程度而增加，原则上每个文法规则对应一个非终结符表达式。

4、上下文环境类（Context）：包含解释器之外的全局信息。它的任务一般是用来存放文法中各个终结符所对应的具体值，比如R=R1+R2，给R1赋值1，给R2赋值2，这些信息需要存放到环境中。

二、解释器模式的应用场景

1、一些重复出现的问题可以用一种简单的语言来进行表达。

2、一个简单语法需要接受的场景。

三、解释器模式的通用写法

抽象表达式：Expression

public interface Expression {

    // 对表达式进行解释
    Object interpret(Context context);
}

上下文环境类：Context

public class Context extends HashMap{
}

非终结符表达式：NonterminalExpression

public class NonterminalExpression implements Expression{
    private Expression [] expressions;

    public NonterminalExpression(Expression... expressions) {
        // 每个非终结符表达式都会对其他表达式产生依赖
        this.expressions = expressions;
    }


    @Override
    public Object interpret(Context context) {
        // 进行文法处理
        context.put("","");
        return null;
    }
}

终结符表达式：TerminalExpression

public class TerminalExpression implements Expression{

    private Object value;

    @Override
    public Object interpret(Context context) {
        // 实现文法中与终结符有关的操作
        context.put("","");
        return null;
    }
}

四、解释器模式的四则运算代码案例

ArithmeticInterpreter：

public interface ArithmeticInterpreter {

    int interpret();

}

Interpreter：

public abstract class Interpreter implements ArithmeticInterpreter{

    protected ArithmeticInterpreter left;
    protected ArithmeticInterpreter right;

    public Interpreter(ArithmeticInterpreter left, ArithmeticInterpreter right) {
        this.left = left;
        this.right = right;
    }
    
}

NumInterpreter：

public class NumInterpreter implements ArithmeticInterpreter {

    private int value;

    public NumInterpreter(int value) {
        this.value = value;
    }


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

AddInterpreter：

public class AddInterpreter extends Interpreter {

    public AddInterpreter(ArithmeticInterpreter left, ArithmeticInterpreter right) {
        super(left, right);
    }

    @Override
    public int interpret() {
        return this.left.interpret() + this.right.interpret();
    }
}

SubInterpreter：

public class SubInterpreter  extends Interpreter {

    public SubInterpreter(ArithmeticInterpreter left, ArithmeticInterpreter right) {
        super(left, right);
    }

    @Override
    public int interpret() {
        return this.left.interpret() - this.right.interpret();
    }
}

MultiInterpreter：

public class MultiInterpreter extends Interpreter {

    public MultiInterpreter(ArithmeticInterpreter left, ArithmeticInterpreter right) {
        super(left, right);
    }

    @Override
    public int interpret() {
        return this.left.interpret() * this.right.interpret();
    }
}

DivInterpreter：

public class DivInterpreter extends Interpreter {

    public DivInterpreter(ArithmeticInterpreter left, ArithmeticInterpreter right) {
        super(left, right);
    }

    @Override
    public int interpret() {
        return this.left.interpret() / this.right.interpret();
    }
}

OperatorUtil：

public class OperatorUtil {

    public static boolean isOperator(String symbol) {
        return ("+".equals(symbol) || "-".equals(symbol) || "*".equals(symbol));
    }

    public static Interpreter getInterpreter(ArithmeticInterpreter left, ArithmeticInterpreter right, String symbol) {
        if ("+".equals(symbol)) {
            return new AddInterpreter(left, right);
        } else if ("-".equals(symbol)) {
            return new SubInterpreter(left, right);
        } else if ("*".equals(symbol)) {
            return new MultiInterpreter(left, right);
        } else if ("/".equals(symbol)) {
            return new DivInterpreter(left, right);
        }
        return null;
    }

}

Calculator：

public class Calculator {

    private Stack<ArithmeticInterpreter> stack = new Stack<ArithmeticInterpreter>();

    public Calculator(String expression) {
        this.parse(expression);
    }

    private void parse(String expression) {
        String [] elements = expression.split(" ");
        ArithmeticInterpreter leftExpr, rightExpr;

        for (int i = 0; i < elements.length ; i++) {
            String operator = elements[i];
            if (OperatorUtil.isOperator(operator)){
                leftExpr = this.stack.pop();
                rightExpr = new NumInterpreter(Integer.valueOf(elements[++i]));
                System.out.println("出栈: " + leftExpr.interpret() + " 和 " + rightExpr.interpret());
                this.stack.push(OperatorUtil.getInterpreter(leftExpr, rightExpr,operator));
                System.out.println("应用运算符: " + operator);
            }
            else{
                NumInterpreter numInterpreter = new NumInterpreter(Integer.valueOf(elements[i]));
                this.stack.push(numInterpreter);
                System.out.println("入栈: " + numInterpreter.interpret());
            }
        }
    }

    public int calculate() {
        return this.stack.pop().interpret();
    }

}

测试类：

public class Test {

    public static void main(String[] args) {
        System.out.println("result: " + new Calculator("10 + 30").calculate());
        System.out.println("result: " + new Calculator("10 + 30 - 20").calculate());
        System.out.println("result: " + new Calculator("100 * 2 + 400 - 20 + 66").calculate());
    }

}

五、解释器模式的优缺点

（一）、优点

1、扩展性强：在解释器模式中由于语法是由很多类表示的，当语法规则更改时，只需修改相应的非终结符表达式即可，若扩展语法时，只需添加相应非终结符类即可。

2、添加了新的解释表示式的方式。

3、易于实现文法：解释器模式对应的文法应当是比较简单且易于实现的，过于复杂的语法并不适合使用解释器模式。

（二）、缺点

1、语法规则较复杂时，会引起类膨胀：解释器模式每个语法都要尝试一个非终结符表达式，当语法规则比较复杂时，就会产生大量的解释类，增加系统维护困难。

2、执行效率比较低：解释器模式采用递归调用方法，每个非终结符表达式只关心与自己有关的表达式，每个表达式需要知道最终的结果，因此完整表达式的最终结果是通过从后往前递归调用的方式获取到的。当完整表达式层次较深时，解释效率下降，且出错时调试困难，因为递归迭代层级太深。

六、设计模式的相关博客文章链接

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
解释器模式详解附有代码案例分析

解释器模式一、解释器模式的概念与角色（一）、解释器模式的概念（二）、解释器模式的角色二、解释器模式的应用场景三、解释器模式的通用写法四、解释器模式的四则运算代码案例五、解释器模式的优缺点（一）、优点（二）、缺点一、解释器模式的概念与角色（一）、解释器模式的概念解释器模式是指给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来接受语言中的句子。是一种按照规定的语法进行解析的模式，属于行为型模式。解释器模式的作用其实与编译器一样，都是将一些固定的语法进行接受，构建出一
复制链接

扫一扫