设计模式-解释器模式

标签：解释器 right calculate 模式 new 设计模式 public interpret IArithmeticInterpreter

解释器模式(InterPreter Pattern)

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

比如编译器可以将源码编译为机器码，让CPU能进行识别并运行。解释器模式的作用其实与编译器一样，都是对固定的文法进行解释，构建出一个解释句子的解释器。

解释器模式实际开发中使用较少，一般源码中会使用，比如Spring的el表达式，以及jdk对正则的支持等

适用场景

一些重复出现的问题可以用一种简单的语言来进行表达
一个简单语法需要解释的场景

角色

抽象表达式Expression：负责定义一个解释方法interpret，交由具体子类进行具体解释
终结符表达式TerminalExpression：实现文法中与终结符有关的操作。文法中的每一个终结符都有一个具体终结表达式与之相呼应。比如R=R1+R2,R1与R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式。通常一个解释器模式中只有一个终结符表达式，但有多个实例，对应不同的终结符(R1,R2)。
非终结符表达式NonTerminalExpression:实现文法中与非终结符有关的解释操作。文法中的每条规则都对应于一个非终结符表达式。非终结表达式一般是文法中的运算符或者其他关键字。
上下文环境类Context：包含解释器之外的全局信息。他的任务一般是用来存放文法中各个终结符所对应的具体值。

代码示例

用解释器模式实现一个数学表达式计算器

抽象表达式角色：

package com.caozz.demo2.interpreter.calculate;

public interface IArithmeticInterpreter {
    int interpret();
}

非终结表达式角色抽象

package com.caozz.demo2.interpreter.calculate;

public abstract class SymbolInterpreter implements IArithmeticInterpreter {

    protected IArithmeticInterpreter left;
    protected IArithmeticInterpreter right;

    public SymbolInterpreter(IArithmeticInterpreter left, IArithmeticInterpreter right) {
        this.left = left;
        this.right = right;
    }
}

具体非终结表达式（加减乘除）

package com.caozz.demo2.interpreter.calculate;

public class AddInterpreter extends SymbolInterpreter {

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

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

package com.caozz.demo2.interpreter.calculate;

public class SubInterpreter extends SymbolInterpreter {
    public SubInterpreter(IArithmeticInterpreter left, IArithmeticInterpreter right) {
        super(left, right);
    }

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

package com.caozz.demo2.interpreter.calculate;

public class MultiInterpreter extends SymbolInterpreter {

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

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

}

package com.caozz.demo2.interpreter.calculate;

public class DivInterpreter extends SymbolInterpreter {

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

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

}

终结符表达式（数字表达式）

package com.caozz.demo2.interpreter.calculate;

public class NumInterpreter implements IArithmeticInterpreter {
    private int value;

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


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

计算器
parse方法对应的是不考虑优先级的，parse01是考虑优先级的

package com.caozz.demo2.interpreter.calculate;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class GPCalculator {
    private Stack<IArithmeticInterpreter> stack = new Stack<>();
    Queue<IArithmeticInterpreter> finalNum = new LinkedList<>();

    public GPCalculator(String expression) {
//        this.parse(expression);
        this.parse01(expression);
    }

    private void parse(String expression) {
        String [] elements = expression.split(" ");
        IArithmeticInterpreter 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());
            }
        }
    }


    private void parse01(String expression) {
        String [] elements = expression.split(" ");
        Queue<String> symbols = new LinkedList<>();
        Queue<String> nums = new LinkedList<>();

        for (int i = 0; i < elements.length ; i++) {
            String ele = elements[i];
            if (OperatorUtil.isOperator(ele)){
                symbols.offer(ele);
            } else {
                nums.offer(ele);
            }
        }

        //先计算乘法
        Stack<String> nsymbols = new Stack<>();
        Stack<IArithmeticInterpreter> nnums = new Stack<>();
        nnums.push(new NumInterpreter(Integer.valueOf(nums.poll())));
        int symbolLen = symbols.size();
        for (int j = 0; j < symbolLen; j++) {
            String operator = symbols.poll();
            IArithmeticInterpreter next = new NumInterpreter(Integer.valueOf(nums.poll()));
            if (OperatorUtil.isAddSub(operator)) {
                nsymbols.push(operator);
                nnums.push(next);
            } else {
                IArithmeticInterpreter previous = nnums.pop();
                nnums.push(new MultiInterpreter(previous,next));
            }
        }


        //乘法计算完成后的
        int len = nsymbols.size();
        IArithmeticInterpreter first = nnums.pop();
        finalNum.offer(first);
        for (int h = 0; h < len; h++) {
            String e = nsymbols.pop();
            IArithmeticInterpreter pre = finalNum.poll();
            IArithmeticInterpreter next = nnums.pop();
            if ("+".equals(e)) {
                finalNum.offer(new AddInterpreter(pre,next));
            } else {
                finalNum.offer(new SubInterpreter(next,pre));
            }
        }
    }



    public int calculate() {
//        return this.stack.pop().interpret();
        IArithmeticInterpreter poll = this.finalNum.poll();
        return poll.interpret();
    }
}

测试

package com.caozz.demo2.interpreter.calculate;

public class Test {

    public static void main(String[] args) {
        System.out.println("result(10 + 30): " + new GPCalculator("10 + 30").calculate());
        System.out.println("result(       50 + 30 - 20       ): " + new GPCalculator("50 + 30 - 20").calculate());
        System.out.println("result(        2 + 5 * 3         ): " + new GPCalculator("2 + 5 * 3").calculate());
        System.out.println("result(       2 * 3 + 4 * 5      ): " + new GPCalculator("2 * 3 + 4 * 5").calculate());
        System.out.println("result(    2 * 3 * 5 + 4 * 5     ): " + new GPCalculator("2 * 3 * 5 + 4 * 5").calculate());
        System.out.println("result(    2 * 5 + 4 * 5 * 6     ): " + new GPCalculator("2 * 5 + 4 * 5 * 6").calculate());
        //15 + 15 + 60 = 90
        System.out.println("result(3 * 5 + 6 + 9 + 2 * 3 * 10): " + new GPCalculator("3 * 5 + 6 + 9 + 2 * 3 * 10").calculate());
    }

}

测试结果

D:\software\java\jdk-17.0.2\bin\java.exe ...
result(10 + 30): 40
result(       50 + 30 - 20       ): 60
result(        2 + 5 * 3         ): 17
result(       2 * 3 + 4 * 5      ): 26
result(    2 * 3 * 5 + 4 * 5     ): 50
result(    2 * 5 + 4 * 5 * 6     ): 130
result(3 * 5 + 6 + 9 + 2 * 3 * 10): 90

Process finished with exit code 0

欢迎大家留言，以便于后面的人更快解决问题！另外亦欢迎大家可以关注我的微信公众号，方便利用零碎时间互相交流。共勉！

标签：解释器,right,calculate,模式,new,设计模式,public,interpret,IArithmeticInterpreter
From： https://www.cnblogs.com/caozz/p/18262887/interpreter

解释器模式(InterPreter Pattern)

适用场景

角色

代码示例

欢迎大家留言，以便于后面的人更快解决问题！另外亦欢迎大家可以关注我的微信公众号，方便利用零碎时间互相交流。共勉！

相关文章

赞助商

阅读排行