【设计模式】行为型11解释器模式（Interpreter Pattern）

  解释器模式（Interpreter Pattern）

解释器模式应用场景比较小，也没有固定的DEMO，中心思想就是自定义解释器用来解释固定的对象。

定义：给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。

 

  DEMO的话随便转载了一个写的比较清晰的博主的博客，博主信息如下（代码做了微小修改）：

  @Author      风一样的码农
  @HomePageUrl http://www.cnblogs.com/chenpi/
  @Copyright      转载请注明出处，谢谢~

代码：

1、解释器规则：

package com.pat.Interpreter;

import java.util.Map;

/*
 * 解释器规则类，本类定义一些语法规则，解释器应用本类中的规则进行解析文本
 * @author ZX
 */

/**
 * 条件表达式接口，用于解析语法规则
 * @author ZX
 */
public interface Expression {
	public int interpret(Map<String,Expression> variables);
}
/**
 * 数字
 */
class Number implements Expression{
    private int number;
	@Override
	public int interpret(Map<String, Expression> variables) {

		return number;
	}
	public Number() {}
	public Number(int number) {
		this.number=number;
	}

}
/**
 * 加
 */
class Plus implements Expression{
	private Expression leftExp;
	private Expression rightExp;
	@Override
	public int interpret(Map<String, Expression> variables) {

		return leftExp.interpret(variables)+rightExp.interpret(variables);
	}
	public Plus(){}
	public Plus(Expression leftExp,Expression rightExp){
		this.leftExp=leftExp;
		this.rightExp=rightExp;
	}
}
/**
 * 减
 */
class Minus implements Expression{
	private Expression leftExp;
	private Expression rightExp;
	@Override
	public int interpret(Map<String, Expression> variables) {

		return leftExp.interpret(variables)-rightExp.interpret(variables);
	}
	public Minus(){}
	public Minus(Expression leftExp,Expression rightExp){
		this.leftExp=leftExp;
		this.rightExp=rightExp;
	}

}
/**
 * 变量
 */
class Variable  implements Expression{
	private String name;
	@Override
	public int interpret(Map<String, Expression> variables) {
		if(variables==null) {return 0;}
		return variables.get(name).interpret(variables);
	}
	public Variable(String name) {
		this.name=name;
	}
}

2、解释器：

package com.pat.Interpreter;

import java.util.Map;
import java.util.Stack;
/**
 * 解释器，继承解释器规则类
 * @author ZX
 * 知识点补充
   peek()与pop()
       相同点：大家都返回栈顶的值。
       不同点：peek 不改变栈的值(不删除栈顶的值)，pop会把栈顶的值删除。
 */
public class Evaluator implements Expression{
    private Expression syntaxTree;

    public Evaluator(String expression) {
    	if(expression==null||"".equals(expression)) {return;}
    	Stack<Expression> expreStack = new Stack<Expression>();
    	String[] tokens  = expression.split(",");
    	for(String token:tokens) {
    		if("+".equals(token)) {
    			Expression subExpression = new Plus(expreStack.pop(),expreStack.pop());
    			expreStack.push(subExpression);
    		}else if("-".equals(token)) {
    			Expression subExpression = new Minus(expreStack.pop(),expreStack.pop());
    			expreStack.push(subExpression);
    		}else {
    			expreStack.push(new Variable(token));
    		}
    	}
    	syntaxTree=expreStack.pop();
    }

	@Override
	public int interpret(Map<String, Expression> variables) {
		// TODO Auto-generated method stub
		return syntaxTree.interpret(variables);
	}

}

3、测试类：

package com.pat.Interpreter;

import java.util.HashMap;
import java.util.Map;

public class Test {
	public static void main(String[] args) {
		 String expression = "w,x,z,-,+";
		 Evaluator eva = new Evaluator(expression);
		 Evaluator sentence = new Evaluator(expression);
	        Map<String,Expression> variables = new HashMap<String,Expression>();
	        variables.put("w", new Number(5));
	        variables.put("x", new Number(10));
	        variables.put("z", new Number(42));
	        //求5-10+42
	        int result = sentence.interpret(variables);
	        System.out.println(result);
	}
}

4、结果：

//求5-10+42  》》》》37