解释器模式

简介：解释器模式提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。

适用场景： 1、可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。 2、一些重复出现的问题可以用一种简单的语言来进行表达。 3、一个简单语法需要解释的场景。

解释器模式一般使用较少，在开发中碰到类似场景可以使用expression4J 进行代替。

自己的理解：就是解释器模式能够按照设定的规则，将特定的文法进行解释返回结果，文法在java中大多都是字符串，比如对sql语句进行解释。对数学运算符进行解释运算。

下面的是一个关于正整数进行加减的例子。（这个例子写得不是很好，算抛砖引玉吧）

/**
 *定义一个抽象表达式接口
 */
public interface Expression {
	public int interpret();

}


/**
 *终结符表达式（操作数）
 */
class NumExpression  implements Expression{
	private int num;
	
	

	public NumExpression(int num) {
		super();
		this.num = num;
	}



	@Override
	public int interpret() {
		// TODO Auto-generated method stub
		return num;
	}
	
}


/**
 *非终结表达式（加法操作符）
 */
class PlusExpression implements Expression{
	
	//左右操作数
	private Expression left;
	private Expression right;
	
	

	public PlusExpression(Expression left, Expression right) {
		super();
		this.left = left;
		this.right = right;
	}



	//返回两个操作数相加后的值
	@Override
	public int interpret() {
		// TODO Auto-generated method stub
		return left.interpret()+right.interpret();
	}
	
}


/**
 *非终结表达式（加法操作符）
 */
class MinusExpression implements Expression{
	//左右操作数
	private Expression left;
	private Expression right;
	
	

	public MinusExpression(Expression left, Expression right) {
		super();
		this.left = left;
		this.right = right;
	}



	//返回两个操作数相减后的值
	@Override
	public int interpret() {
		// TODO Auto-generated method stub
		return left.interpret()-right.interpret();
	}
}

/**
 *对字符串进行分割，返回一个数组，数组中的值是操作数和操作符，并且保证顺序。
 *比如将“23+12-7”分割为“23”，“+”，“12”，“-”，“7”
 */
class ExpressionTool{
	private String str;

	public ExpressionTool(String string) {
		super();
		this.str = string;
	}
	
	public String[] getArr(){
		//使用TreeMap是因为TreeMap的键值有顺序。
		Map map=new TreeMap<>();
        Pattern p;
        Matcher m;
        p = Pattern.compile("\\+|\\-|\\*|\\/|\\(|\\)");
        m = p.matcher(str);
        //得到所有的操作符以及索引
        while(m.find()){
            map.put(m.start(), m.group());
           
        }
        p = Pattern.compile("\\d+(\\.\\d+)*");
        m = p.matcher(str);
        //得到所有操作数以及索引
        while(m.find()){
            map.put(m.start(), m.group());
        }
		
        
        String[] arr=new String[map.size()];
        
        Set<Integer> set=map.keySet();
        
        Iterator<Integer> iterator=set.iterator();
        
        int i=0;
        while(iterator.hasNext()){
        	arr[i]=(String) map.get(iterator.next());
        	i++;
        }
        
        return arr;
	}
}

/**
 *对表达式进行处理，得到计算结果
 */
class Client{
	//表达式
	private String exp;
	
	public Client(String exp) {
		super();
		this.exp = exp.replace(" ", "");
	}
	
	public int calculate(){
		//对字符串进行切割
		String[] str=new ExpressionTool(exp).getArr();
		
		int value=Integer.valueOf(str[0]);
		for (int i = 0; i < str.length; i++) {
			
			
			if(str[i].equals("+")){       //加号
				int left=Integer.valueOf(str[i-1]);
				int right=Integer.valueOf(str[i+1]);
				Expression plusEx=new PlusExpression(new NumExpression(value), new NumExpression(right));
				//arr[0]=plusEx.interpret();
				value=plusEx.interpret();
				
			}else if(str[i].equals("-")){ //减号
				int right=Integer.valueOf(str[i+1]);
				Expression subEx=new MinusExpression(new NumExpression(value), new NumExpression(right));
				value=subEx.interpret();
				
			}else{                        //操作数
				//arr[]
			}
		}
		
		return value;
		
	}
}

主方法：

/**
 *只限于正整数之间的加减运算。
 */
public class Main {

	public static void main(String[] args) {

		Client client=new Client("1111-1+90-3+3+55-50-5+77");
		int value=client.calculate();
		System.err.println(value);
		}

}

运行结果：

1277

参考文章： Java设计模式之解释器模式， java/android 设计模式学习笔记（23）---解释器模式， 解释器模式