设计模式之解释器模式

深碍√TFBOYSˉ_ 2022-08-22 00:14 138阅读 0赞

**解释器模式**定义：给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

优点：

解释器是一个简单语法分析工具，它最显著的优点就是扩展性，修改语法规则只要修改相应的非终结符表达式就可以了，若扩展语法，则只要添加非终结符类就可以了。

缺点：

1、解释器模式会引起类膨胀。

2、解释器模式采用递归调用方法。

3、效率问题。

**类图**如下：

![20160508173517031][]

**实现代码**如下：

抽象的表达式类：

package com.designpatterns.interpreter;
    
    import java.util.HashMap;
    
    /**
     * @author WSYW126
     * @version 创建时间：2016年5月8日 下午4:28:15
     * 类说明：Alljava
     */
    public abstract class AbstractExpression {
    	public abstract int interpreter(HashMap<String, Integer> var);
    }

变量解释器类：

package com.designpatterns.interpreter;
    
    import java.util.HashMap;
    
    /**
     * @author WSYW126
     * @version 创建时间：2016年5月8日 下午4:31:09 类说明：Alljava
     */
    public class VarExpression extends AbstractExpression {
    	private String key;
    
    	public VarExpression(String key) {
    		this.key = key;
    	}
    
    	@Override
    	public int interpreter(HashMap<String, Integer> var) {
    		return var.get(this.key);
    	}
    }

抽象运算符解释器类：

package com.designpatterns.interpreter;
    
    /**
     * @author WSYW126
     * @version 创建时间：2016年5月8日 下午4:33:55 类说明：Alljava
     */
    public abstract class SymbolExpression extends AbstractExpression {
    	protected AbstractExpression left;
    	protected AbstractExpression right;
    
    	public SymbolExpression(AbstractExpression left, AbstractExpression right) {
    		this.left = left;
    		this.right = right;
    	}
    }

加法解释器：

package com.designpatterns.interpreter;
    
    import java.util.HashMap;
    
    /**
     * @author WSYW126
     * @version 创建时间：2016年5月8日 下午5:05:49
     * 类说明：Alljava
     */
    public class AddExpression extends SymbolExpression {
    
    	public AddExpression(AbstractExpression left, AbstractExpression right) {
    		super(left, right);
    	}
    
    	@Override
    	public int interpreter(HashMap<String, Integer> var) {
    		return super.left.interpreter(var)+super.right.interpreter(var);
    	}
    
    }

加法解释器：

package com.designpatterns.interpreter;
    
    import java.util.HashMap;
    
    /**
     * @author WSYW126
     * @version 创建时间：2016年5月8日 下午5:04:45
     * 类说明：Alljava
     */
    public class SubExpression extends SymbolExpression {
    
    	public SubExpression(AbstractExpression left, AbstractExpression right) {
    		super(left, right);
    	}
    
    	@Override
    	public int interpreter(HashMap<String, Integer> var) {
    		return super.left.interpreter(var)-super.right.interpreter(var);
    	}
    
    }

解析器封装类：

package com.designpatterns.interpreter;
    
    import java.util.HashMap;
    import java.util.Stack;
    
    /**
     * @author WSYW126
     * @version 创建时间：2016年5月8日 下午5:06:26 类说明：Alljava
     */
    public class Calculator {
    	private AbstractExpression AE;
    
    	public Calculator(String expStr) {
    		Stack<AbstractExpression> s = new Stack<AbstractExpression>();
    		char[] chararray = expStr.toCharArray();
    		AbstractExpression left = null;
    		AbstractExpression right = null;
    		for (int i = 0; i < chararray.length; i++) {
    			switch (chararray[i]) {
    			case '+':
    				left = s.pop();
    				right = new VarExpression(String.valueOf(chararray[++i]));
    				s.push(new AddExpression(left, right));
    				break;
    
    			case '-':
    				left = s.pop();
    				right = new VarExpression(String.valueOf(chararray[++i]));
    				s.push(new SubExpression(left, right));
    				break;
    			default:
    				s.push(new VarExpression(String.valueOf(chararray[i])));
    				break;
    			}
    		}
    		this.AE = s.pop();
    	}
    
    	public int run(HashMap<String, Integer> var) {
    		return this.AE.interpreter(var);
    	}
    }

测试类：

package com.designpatterns.interpreter;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.HashMap;
    
    /**
     * @author WSYW126
     * @version 创建时间：2016年5月8日 下午5:14:28 类说明：Alljava
     */
    public class Client {
    
    	public static void main(String[] args) throws IOException {
    		String expStr = getExpStr();
    		HashMap<String, Integer> var = getValue(expStr);
    		Calculator cal = new Calculator(expStr);
    		System.out.println("运算结果为：" + expStr + "=" + cal.run(var));
    
    	}
    
    	private static HashMap<String, Integer> getValue(String expStr)
    			throws IOException {
    		HashMap<String, Integer> map = new HashMap<String, Integer>();
    		for (char ch : expStr.toCharArray()) {
    			if (ch != '+' && ch != '-') {
    				if (!map.containsKey(String.valueOf(ch))) {
    					String in = (new BufferedReader(new InputStreamReader(
    							System.in))).readLine();
    					map.put(String.valueOf(ch), Integer.valueOf(in));
    				}
    			}
    		}
    		return map;
    	}
    
    	private static String getExpStr() throws IOException {
    		System.out.println("请输入计算的表达式：");
    		return (new BufferedReader(new InputStreamReader(System.in)))
    				.readLine();
    	}
    
    }

这就是解释器模式。

**参考资料**：  
[设计模式之禅][Link 1]  
  
**备注**：  
转载请注明出处：http://blog.csdn.net/wsyw126/article/details/51336078  
作者：WSYW126

[20160508173517031]: /images/20220724/f1cceb70d2ff445baac4ea7e69c00ca5.png
[Link 1]: http://download.csdn.net/detail/wsyw126/9508137