java设计模式——解释器模式

一、解释器模式的定义与类型

1、定义

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

2、类型

• 行为型

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

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

三、解释器模式的优点

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

四、解释器模式的缺点

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

五、解释器模式的相关设计模式

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

六、解释器模式示例

以表达式的计算为例进行代码演示

1、代码结构如下：

2、创建一个解释器接口类

package com.rf.designPatterns.interpreter;

/**
 * 解释器接口类
 * xz
 */
public interface Interpreter {
     int interpreter();
}

3、定义一个加法解释器类，实现解释器接口类

package com.rf.designPatterns.interpreter;

/**
 * @description: 加法解释器
 * @author: xz
 */
public class AddInterpreter implements Interpreter{
    //第一个表达式
    private Interpreter firstExpression;
    //第二个表达式
    private Interpreter secondExpression;

    //构造器注入
    public AddInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }
    //重写解释器的interpreter方法
    @Override
    public int interpreter() {
        //调用interpreter方法是为了转成int类型
        return this.firstExpression.interpreter() + this.secondExpression.interpreter();
    }
    //重写toString方法
    @Override
    public String toString() {
        return "+";
    }
}

4、定义一个乘法法解释器类，实现解释器接口类

package com.rf.designPatterns.interpreter;

/**
 * @description: 乘法解释器
 * @author: xz
 */
public class MultiInterpreter implements Interpreter{
    //第一个表达式
    private Interpreter firstExpression;
    //第二个表达式
    private Interpreter secondExpression;

    //构造器注入
    public MultiInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }
    //重写解释器的interpreter方法
    @Override
    public int interpreter() {
        //调用interpreter方法是为了转成int类型
        return this.firstExpression.interpreter() * this.secondExpression.interpreter();
    }
    //重写toString方法
    @Override
    public String toString() {
        return "*";
    }
}

5、定义一个数字解释器类，实现解释器接口类

package com.rf.designPatterns.interpreter;

/**
 * @description: 数字解释器
 * @author: xz
 */
public class NumberInterpreter implements Interpreter{
    //声明了一个number属性
    private int number;
    //构造器（重载）
    public NumberInterpreter(int number) {
        this.number = number;
    }
    //构造器（重载）
    public NumberInterpreter(String number) {
        this.number = Integer.parseInt(number);
    }
    //重写解释器的interpreter方法
    @Override
    public int interpreter() {
        return this.number;
    }
}

6、定义一个运算符工具类

package com.rf.designPatterns.interpreter;

/**
 * @description: 运算符工具类
 * @author: xz
 */
public class OperatorUtil {
    //判断是否是运算符
    public static boolean isOperator(String string){
        return ("+".equals(string) || "*".equals(string));
    }

    /**
     * @param firstExpression 第一个表达式
     * @param secondExpression 第二个表达式
     * @param str 运算符
     * @return
     */
    public static Interpreter getExpressionObject(Interpreter firstExpression,Interpreter secondExpression,String str){
        if("+".equals(str)){//返回加法解释器
            return new AddInterpreter(firstExpression,secondExpression);
        }else if("*".equals(str)){//返回乘法解释器
            return new MultiInterpreter(firstExpression,secondExpression);
        }
        return null;
    }

}

7、定义一个表达式的解析类

package com.rf.designPatterns.interpreter;

import java.util.Stack;

/**
 * @description: 表达式的解析类
 * @author: xz
 */
public class InterpreterExpressionParser {

    //定义一个栈（先进后出）
    private Stack stack =new Stack();

    //表达式的解析方法
    public int expressionParser(String string){
        String[] strArray =string.split(" ");
        for(String str : strArray){
            if(!OperatorUtil.isOperator(str)){//不是运算符号
                NumberInterpreter numberExpression = new NumberInterpreter(str);
                stack.push(numberExpression);//入栈
                System.out.println(String.format("入栈：%d",numberExpression.interpreter()));
            }else{//是运算符号，可以计算
                Interpreter firstExpression = stack.pop();//出栈第一个
                Interpreter secondExpression = stack.pop();//出栈第二个
                System.out.println(String.format("出栈：%d 和 %d",
                        firstExpression.interpreter(),secondExpression.interpreter()));

                Interpreter operator=OperatorUtil.getExpressionObject(firstExpression,secondExpression,str);
                System.out.println(String.format("运算符：%s",operator));
                int result = operator.interpreter();//转成int类型

                NumberInterpreter Numberresult = new NumberInterpreter(result);
                stack.push(Numberresult);//入栈
                System.out.println(String.format("最后入栈结果：%d",Numberresult.interpreter()));
            }
        }
        int result=stack.pop().interpreter();
        return result;
    }

}

8、定义一个解释器模式测试类

package com.rf.designPatterns.interpreter;

/**
 * @description: 解释器模式测试类
 * @author: xz
 */
public class Test {
    public static void main(String[] args) {
        String inputString ="8 50 11 + *";
        InterpreterExpressionParser expressionParser = new InterpreterExpressionParser();
        int result = expressionParser.expressionParser(inputString);
        System.out.println("解释器的计算器结果"+result);
    }
}

9、运行测试类，输出结果如下：

10、UML类图如下：

七、解释器模式在jdk源码中的应用

1、java.util包下的正则表达式Pattern类，应用到了解释器模式