GoF设计模式-解释器模式

    解释器模式(不重要)：
        类行为型模式，定义语言的文法，建立一个解释器来解释该语言中的句子
        解释器的结构：
            (1)抽象表达式：声明抽象的解释操作，是终结符表达式和非终结符表达式的公共父类
            (2)终结符表达式实现与文法中的终结符相关联的解释操作(叶子节点)
            (3)非终结符表达式实现文法中非终结符的解释操作(非叶子节点)
            (4)环境类(上下文类)：存储解释器之外的一些全局信息
        
    解释器模式的适用场景：
        1.主要应用在面向对象语言开发的编译器和解释器设计
        2.将一个需要执行语言中的句子表示为一个抽象语法树
        3.文法较为简单的时候
    
    解释器模式的优点：
        1.易于改变和扩展文法
        2.易于实现文法
        3.增加新的文法表达式不需修改原有代码，符合开闭原则
    
    解释器模式的缺点：
        1.对于复杂的文法难以维护，包含太多文法规则会使表达式类增多，难以维护
        2.使用了循环和递归，执行效率低
        3.应用场景有限

解释器模式的例子

抽象表达式接口

public interface Node {
	public int interpret();
}

终结符表达式

public class ValueNode implements Node{

	private int value;
	
	public ValueNode(int value) {
		this.value = value;
	}
	 /**
	 * @Description: TODO
	 * @author doudou
	 * @date 2019年10月14日
	 * @return
	 * @throws
	 * @return
	 * @see behavioral.InterpreterPattern.Node#interpret()
	*/
	@Override
	public int interpret() {
		return this.value;
	}

}

抽象非终结符表达式

public abstract class SymbolNode implements Node{

	protected Node left;
	protected Node right;
	
	public SymbolNode(Node left,Node right) {
		this.left = left;
		this.right = right;
	}
	
}

非终结符表达式

public class MulNode extends SymbolNode{

	public MulNode(Node left, Node right) {
		super(left, right);
	}

	 /**
	 * @Description: TODO
	 * @author doudou
	 * @date 2019年10月14日
	 * @return
	 * @throws
	 * @return
	 * @see behavioral.InterpreterPattern.Node#interpret()
	*/
	@Override
	public int interpret() {
		return super.left.interpret() * super.right.interpret();
	}
	
}

public class DivNode extends SymbolNode{

	public DivNode(Node left, Node right) {
		super(left, right);
	}

	 /**
	 * @Description: TODO
	 * @author doudou
	 * @date 2019年10月14日
	 * @return
	 * @throws
	 * @return
	 * @see behavioral.InterpreterPattern.Node#interpret()
	*/
	@Override
	public int interpret() {
		return super.left.interpret() / super.right.interpret();
	}

}

public class ModNode extends SymbolNode{

	public ModNode(Node left, Node right) {
		super(left, right);
	}

	 /**
	 * @Description: TODO
	 * @author doudou
	 * @date 2019年10月14日
	 * @return
	 * @throws
	 * @return
	 * @see behavioral.InterpreterPattern.Node#interpret()
	*/
	@Override
	public int interpret() {
		return super.left.interpret() % super.right.interpret();
	}

}

环境类-解释器封装类-计算器类

public class Calculator {
	
	//private String statement;
	private Node node;
	
	public void build(String statement) {
		Node left,right;
		Stack<Node> stack = new Stack<Node>();
		String[] statementArr = statement.split(" ");
		
		for (int i = 0; i < statementArr.length; i++) {
			if (statementArr[i].equalsIgnoreCase("*")) {
				left = stack.pop();
				int value = Integer.parseInt(statementArr[++i]);
				right = new ValueNode(value);
				stack.push(new MulNode(left, right));
			}else if (statementArr[i].equalsIgnoreCase("/")) {
				left = stack.pop();
				int value = Integer.parseInt(statementArr[++i]);
				right = new ValueNode(value);
				stack.push(new DivNode(left, right));
			}else if (statementArr[i].equalsIgnoreCase("%")) {
				left = stack.pop();
				int value = Integer.parseInt(statementArr[++i]);
				right = new ValueNode(value);
				stack.push(new ModNode(left, right));
			}else {
				stack.push(new ValueNode(Integer.parseInt(statementArr[i])));
			}
		}
		
		this.node = stack.pop();
	}
	
	public int compute() {
		return node.interpret();
	}
	
}

测试类

public class Main {
	public static void main(String[] args) {
		String statement = "3 * 4 / 2 % 4";
		Calculator calculator = new Calculator();
		calculator.build(statement);
		int result = calculator.compute();
		System.out.println(statement+" = "+result);
	}
}

    解释器模式的应用：
        1.使用面向对象语言，如java，开发一个简单的解释器或编译器