解释器模式

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

2.类型：行为型

3.适用场景：某个特定类型问题发生频率足够高

4.优点：语法由很多类表示，容易改变及扩展此“语言”。

5.缺点：当语法规则数目太多时，增加了系统复杂度。

6.相关设计模式：适配器模式

7.实例目录package

8.实例UML类图

9.代码

package com.geely.design.pattern.behavioral.interpreter;

public interface Interpreter {
    int interpret();
}

package com.geely.design.pattern.behavioral.interpreter;

public class AddInterpreter implements Interpreter{
    private Interpreter firstExpression, secondExpression;
    public AddInterpreter(Interpreter firstExpression,Interpreter secondExpression){
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }
    @Override
    public int interpret() {
        return firstExpression.interpret() + secondExpression.interpret();
    }

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

package com.geely.design.pattern.behavioral.interpreter;

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

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

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

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

package com.geely.design.pattern.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 number;
    }
}

package com.geely.design.pattern.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.geely.design.pattern.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",symbol));
                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.geely.design.pattern.behavioral.interpreter;

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

package com.geely.design.pattern.behavioral.interpreter;

import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;

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