标签：
概述
解释器模式是一种使用频率相对较低但学习难度较大的设计模式，它用于描述如何使用面向对象语言构成一个简单的语言解释器。在某些情况下，为了更好地描述某一些特定类型的问题，我们可以创建一种新的语言，这种语言拥有自己的表达式和结构，即文法规则，这些问题的实例将对应为该语言中的句子。此时，可以使用解释器模式来设计这种新的语言。对解释器模式的学习能够加深我们对面向对象思想的理解，并且掌握编程语言中文法规则的解释过程
定义
解释器模式(Interpreter Pattern)：定义一个语言的文法，并且建立一个解释器来解释该语言中的句子，这里的“语言”是指使用规定格式和语法的代码。解释器模式是一种类行为型模式。
实现
节点类
public interface Node { /// <summary> /// 翻译方法 /// </summary> /// <returns></returns> int Interpret(); }
值节点【非终结符表达式】
public class ValueNode : Node { private int value; public ValueNode(int value) { this.value = value; } public int Interpret() { return this.value; } }
符号节点【终结符表达式】
public abstract class SymbolNode : Node { protected Node left; protected Node right; public SymbolNode(Node left, Node right) { this.left = left; this.right = right; } public abstract int Interpret(); }
加法节点
public class AddNode : SymbolNode { public AddNode(Node left, Node right) : base(left, right) { } public override int Interpret() { return base.left.Interpret() + base.right.Interpret(); } }
减法
public class SubNode : SymbolNode { public SubNode(Node left, Node right) : base(left, right) { } public override int Interpret() { return base.left.Interpret() - base.right.Interpret(); } }
乘法
public class MulNode : SymbolNode { public MulNode(Node left, Node right) : base(left, right) { } public override int Interpret() { return base.left.Interpret() * base.right.Interpret(); } }
除法
public class DivNode : SymbolNode { public DivNode(Node left, Node right) : base(left, right) { } public override int Interpret() { return base.left.Interpret() / base.right.Interpret(); } }
计算处理类
public class Calculator { private Node node; public void build(String statement) { Node leftNode, rightNode; char[] charArray = statement.ToCharArray(); string[] statementArr = charArray.Select(p => p.ToString()).Where(p => !string.IsNullOrWhiteSpace(p)).ToArray(); for (int i = 0; i < statementArr.Length; i++) { if (statementArr[i].Equals("*")) { leftNode = node; rightNode = new ValueNode(int.Parse(statementArr[++i])); node = new MulNode(leftNode, rightNode); } else if (statementArr[i].Equals("/")) { leftNode = node; rightNode = new ValueNode(int.Parse(statementArr[++i])); node = new DivNode(leftNode, rightNode); } else if (statementArr[i].Equals("%")) { leftNode = node; rightNode = new ValueNode(int.Parse(statementArr[++i])); node = new ModNode(leftNode, rightNode); } else { node = new ValueNode(int.Parse(statementArr[i])); } } } public int Compute() { return node.Interpret(); } }
客户端
class Program { static void Main(string[] args) { String statement = "3 * 2 * 4 / 6 % 5"; Calculator calculator = new Calculator(); calculator.build(statement); int result = calculator.Compute(); Console.ReadLine(); } }
总结
1、 可扩展性比较好，灵活。
2、 增加了新的解释表达式的方式。
3、 易于实现文法。
1、 执行效率比较低，可利用场景比较少。
2、 对于复杂的文法比较难维护。
1、可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。
2、一些重复出现的问题可以用一种简单的语言来进行表达。
3、文法较为简单。
标签：
原文地址：http://www.cnblogs.com/Jabben/p/5596920.html
