标签：
如果在系统中某一特定类型的问题发生的频率很高，此时可以考虑将这些问题的实例表述为一个语言中的句子，因此可以构建一个解释器，该解释器通过解释这些句子来解决这些问题。
解释器模式描述了如何构成一个简单的语言解释器，主要应用在使用面向对象语言开发的编译器中。
解释器模式(Interpreter Pattern) ：定义语言的文法，并且建立一个解释器来解释该语言中的句子，这里的“语言”意思是使用规定格式和语法的代码，它是一种类行为型模式。
输入是一个用字符串表达的四则运算，比如 1 + 2 * 3 。目的是试图去理解这个字符串表达的运算指令，然后计算出结果 7。之所以是一个解释器 Interpreter，而不是一个编译器 Compiler，是因为程序是去理解指令并且执行指令，而不是把指令编译成机器代码来运行；后者是编译器的目标。
第一个部分，是截取输入字符串，然后返回单元指令。比如，对于指令 1 + 2 * 3 – 4 / 5，就需要被分解成如下所示的单元指令集：
第二个部分，把单元指令集组成一个树结构，称之为 Abstract Syntax Tree。按照将来需要解释的顺序，优先执行的指令放在树的叶的位置，最后执行的指令是树根Root。
程序只有 2 种单元指令：操作数 NumExpression 和 运算符 OpExpression 。
定义了一个抽象类，叫做 Expression，然后 NumExpression和 OpExpression 继承了该抽象类。
package design.pattern;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
/**
* 运算符枚举类
*
* @author Administrator
*
*/
enum Op {
Plus(‘+‘), Minus(‘-‘), Multiply(‘*‘), Divide(‘/‘);
char value;
Op(char value) {
this.value = value;
}
static Op getValue(char ch) {
switch (ch) {
case ‘+‘:
return Plus;
case ‘-‘:
return Minus;
case ‘*‘:
return Multiply;
case ‘/‘:
return Divide;
default:
return null;
}
}
}
/**
* 运算符优先级枚举类
*
* @author Administrator
*
*/
enum Prioirty {
Lv2(2), Lv1(1), Lv0(0);
int value;
Prioirty(int value) {
this.value = value;
}
int getValue() {
return value;
}
}
/**
* 抽象表达式
*
* @author Administrator
*
*/
abstract class Expression {
abstract public double interpreter(Syntax root);
}
/**
* 操作数表达式
*
* @author Administrator
*
*/
class NumExpression extends Expression {
private double value;
public NumExpression(double value) {
this.value = value;
}
public double getValue() {
return value;
}
public double interpreter(Syntax root) {
return ((NumExpression) (root.getExpression())).getValue();
}
public String toString() {
return String.valueOf(value);
}
}
/**
* 运算符表达式
*
* @author Administrator
*
*/
class OpExpression extends Expression {
private Op value;
public OpExpression() {
}
public OpExpression(Op value) {
this.value = value;
}
public Op getValue() {
return value;
}
public Prioirty getPrioirty() {
switch (this.value) {
case Plus:
case Minus:
return Prioirty.Lv1;
case Multiply:
case Divide:
return Prioirty.Lv2;
default:
return Prioirty.Lv0;
}
}
public double interpreter(Syntax root) {
double lvalue, rvalue;
if (root.getLeft() == null)
lvalue = 0;
else
lvalue = ((Expression) root.getLeft().getExpression()).interpreter(root.getLeft());
if (root.getRight() == null)
rvalue = 0;
else
rvalue = ((Expression) root.getRight().getExpression()).interpreter(root.getRight());
switch (((OpExpression) root.getExpression()).getValue()) {
case Plus:
return lvalue + rvalue;
case Minus:
return lvalue - rvalue;
case Multiply:
return lvalue * rvalue;
case Divide:
return lvalue / rvalue;
default:
return 0;
}
}
public String toString() {
return value.toString();
}
}
/**
* 解释器
*
* @author Administrator
*
*/
public class Interpreter {
private Expressionizer expressionizer = new Expressionizer();
public SyntaxTree eval(String expr) {
ArrayList<Expression> expressions = expressionizer.parse(expr);
SyntaxTree astree = new SyntaxTree();
for (Expression e : expressions) {
astree.append(e);
}
return astree;
}
public static void main(String[] args) {
System.out.println("请输入表达式");
Scanner scanner = new Scanner(System.in);
String exp = scanner.nextLine();
scanner.close();
Interpreter interpreter = new Interpreter();
// 构建语法树
SyntaxTree context = interpreter.eval(exp);
Expression EXP = new OpExpression();
// 解释语法树
double result = EXP.interpreter(context.getRoot());
System.out.println(result);
}
}
/**
* 语法树节点类
*
* @author Administrator
*
*/
class Syntax {
private Expression expression;
private Syntax left;
private Syntax right;
public Syntax(Expression Expression) {
this.expression = Expression;
this.left = null;
this.right = null;
}
public Expression getExpression() {
return expression;
}
public Syntax getLeft() {
return left;
}
public void setLeft(Syntax value) {
this.left = value;
}
public Syntax getRight() {
return right;
}
public void setRight(Syntax value) {
this.right = value;
}
}
class SyntaxTree {
private Syntax root;
private int count;
public SyntaxTree() {
this.root = null;
this.count = 0;
}
public Syntax getRoot() {
return root;
}
public int getCount() {
return count;
}
public void append(Expression expression) {
this.root = this.append(this.root, expression);
this.count++;
}
/**
* 添加表达式节点到语法树root中
*
* @param root
* 语法树根节点
* @param expression
* 表达式
* @return 语法树新的根节点
*/
private Syntax append(Syntax root, Expression expression) {
// 第一次添加节点
if (root == null) {
Syntax newNode = new Syntax(expression);
root = newNode;
return root;
}
// 添加操作数
if (expression instanceof NumExpression) {
// 如果根节点为运算符，则把操作数添加到右端，否则忽略
if (root.getExpression() instanceof OpExpression) {
// 如果右子树为空则直接添加为右节点
if (root.getRight() == null) {
Syntax newNode = new Syntax(expression);
root.setRight(newNode);
return root;
} else {
// 右子树不为空，作为新的语法树继续添加
root.setRight(this.append(root.getRight(), expression));
return root;
}
}
// 添加运算符
} else if (expression instanceof OpExpression) {
// 如果根节点为操作数，则新的运算符为根节点，操作数加到左端
if (root.getExpression() instanceof NumExpression) {
Syntax newRoot = new Syntax(expression);
newRoot.setLeft(root);
root = newRoot;
return newRoot;
// 如果根节点为运算符，则根据优先级添加新的运算符到语法树
} else if (root.getExpression() instanceof OpExpression) {
OpExpression expression1 = (OpExpression) expression;
OpExpression expression2 = (OpExpression) root.getExpression();
// 新的运算符优先级低于根节点，则将新运算符作为根节点，旧的根加到左端
if (expression1.getPrioirty().getValue() <= expression2.getPrioirty().getValue()) {
Syntax newRoot = new Syntax(expression1);
newRoot.setLeft(root);
root = newRoot;
return newRoot;
} else {
// 新的运算符优先级高于根节点，需要优先运算，则添加到根节点的右子树
root.setRight(append(root.getRight(), expression));
return root;
}
}
}
return root;
}
}
class Expressionizer {
private static Character[] Ops = { ‘+‘, ‘-‘, ‘*‘, ‘/‘ };
// private static Character[] Spaces = { ‘ ‘, ‘\0‘, ‘\t‘, ‘\n‘, ‘\r‘ };
String getStringRepresentation(ArrayList<Character> list) {
StringBuilder builder = new StringBuilder(list.size());
for (Character ch : list) {
builder.append(ch);
}
return builder.toString();
}
/**
* 将字符串转化为表达式序列
*
*/
public ArrayList<Expression> parse(String value) {
ArrayList<Expression> list = new ArrayList<Expression>();
ArrayList<Character> buff = new ArrayList<>();
for (int i = 0; i < value.length(); i++) {
char ch = value.charAt(i);
if (ch >= ‘0‘ && ch <= ‘9‘) {
buff.add(ch);
} else if (ch == ‘.‘) {
buff.add(‘.‘);
} else {
OpExpression expression = null;
// 查找运算符是否在Ops表中
if (Arrays.asList(Ops).indexOf(ch) >= 0) {
expression = new OpExpression(Op.getValue(ch));
}
// 当前表达式为运算符，则buff中存放的数字字符序列为一个单独的操作数
if (buff.size() > 0) {
double num = Double.parseDouble(getStringRepresentation(buff));
Expression expression1 = new NumExpression(num);
list.add(expression1);
buff.clear();
}
if (expression != null) {
list.add(expression);
}
}
}
// 最后留下的一个数字
if (buff.size() > 0) {
double num = Double.parseDouble(getStringRepresentation(buff));
Expression Expression1 = new NumExpression(num);
list.add(Expression1);
buff.clear();
}
// for (Expression c : list)
// System.out.println(c);
return list;
}
}
解释器模式描述了如何为简单的语言定义一个文法，如何在该语言中表示一个句子，以及如何解释这些句子。
文法规则实例
expression ::= value | symbol
symbol ::= expression ‘+’ expression | expression ‘-‘
value ::= an integer //一个整数值
在文法规则定义中可以使用一些符号来表示不同的含义，如使用“|”表示或，使用“{”和“}”表示组合，使用“*”表示出现0次或多次等。
抽象语法树
除了使用文法规则来定义一个语言，在解释器模式中还可以通过一种称之为抽象语法树(Abstract Syntax Tree, AST)的图形方式来直观地表示语言的构成，每一棵抽象语法树对应一个语言实例。
抽象语法树描述了如何构成一个复杂的句子，通过对抽象语法树的分析，可以识别出语言中的终结符和非终结符类。
在解释器模式中，每一种终结符和非终结符都有一个具体类与之对应，正因为使用类来表示每一个语法规则，使得系统具有较好的扩展性和灵活性。
优点
缺点
模式使用
模式应用
解释器模式定义语言的文法，并且建立一个解释器来解释该语言中的句子，这里的“语言”意思是使用规定格式和语法的代码，它是一种类行为型模式。
解释器模式主要包含如下四个角色
对于一个简单的语言可以使用一些文法规则来进行定义，还可以通过抽象语法树的图形方式来直观地表示语言的构成，每一棵抽象语法树对应一个语言实例。
解释器模式的主要优点
其主要缺点是对于复杂文法难以维护，执行效率较低且应用场景很有限。
解释器模式适用情况包括
标签：
原文地址：http://blog.csdn.net/qq_20480611/article/details/51763902
