【设计模式】行为型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

巴特西

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

最新文章

热门文章