35解释器模式(Interpreter Pattern)

动机(Motivate):
    在软件构建过程中，如果某一特定领域的问题比较复杂，类似的模式不断重复出现，如果使用普通的编程方式来实现将面临非常频繁的变化。
    在这种情况下，将特定领域的问题表达为某种文法规则下的句子，然后构建一个解释器来解释这样的句子，从而达到解决问题的目的。
意图(Intent):
    给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
结构图(Struct):

生活中的例子：

适用性：
1.当有一个语言需要解释执行，并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。
而当存在以下情况时该模式效果最好：
2.该文法简单对于复杂的文法，文法的类层次变得庞大而无法管理。此时语法分析程序生成器这样的工具是更好的选择。它们无需构建抽象语法树即可解释表达工，这样可以节省空间而且还可能节省时间。
3.效率不是一个关键问题最高效的解释器通常不是通过直接解释语法分析树实现的，而是首先将它们转换成另一种
形式。例如：正则表达式通常被转换成状态机。但即使在这种情况下，转换器仍可用解释器模式实现，该模式仍
是有用的。
代码实现：
客户端代码如下：

1     class Program
2     {
3         static void Main(string[] args)
4         {
5             string roman = "五千四百三十二"; //5432
6             Context context = new Context(roman);
7
8             //Build the 'parse tree'
9             ArrayList tree = new ArrayList();
10             tree.Add(new OneExpression());
11             tree.Add(new TenExpression());
12             tree.Add(new HundredExpression());
13             tree.Add(new ThousandExpression());
14
15             //Interpret
16             foreach (Expression exp in tree)
17             {
18                 exp.Interpret(context);
19             }
20             Console.WriteLine("{0} = {1}", roman, context.Data);
21             //Wait for user
22             Console.Read();
23         }
24     }

创建一个抽象类Expression，来描述共同的操作。

1     public abstract class Expression
2     {
3         protected Dictionary<string, int> table = new Dictionary<string, int>(9);
4         public Expression()
5         {
6             table.Add("一", 1);
7             table.Add("二", 2);
8             table.Add("三", 3);
9             table.Add("四", 4);
10             table.Add("五", 5);
11             table.Add("六", 6);
12             table.Add("七", 7);
13             table.Add("八", 8);
14             table.Add("九", 9);
15         }
16         public virtual void Interpret(Context context)
17         {
18          if(context.Statement.Length==0)
19             {
20               return;
21             }
22         foreach(string key in table.Keys)
23         {
24          int value=table[key];
25          if(context.Statement.EndsWith(key + GetPostifix()))
26             {
27               context.Data +=value*Multiplier();
28               context.Statement = context.Statement.Substring(0,context.Statement.Length- this.GetLength());
29             }
30
31             if(context.Statement.EndsWith("零"))
32             {
33                 context.Statement = context.Statement.Substring(0, context.Statement.Length - 1);
34             }
35             if (context.Statement.Length == 0)
36             {
37                 return;
38             }
39          }
40        }
41
42         public abstract string GetPostifix();
43         public abstract int Multiplier();
44         public virtual int GetLength()
45         {
46             return this.GetPostifix().Length + 1;
47         }
48     }

然后创建一个公共类Context,定义一些全局信息。

1    public class Context
2     {
3         private string statement;
4         private int data;
5
6         //Constructor
7         public Context(string statement)
8         {
9             this.statement = statement;
10         }
11         //Properties
12         public string Statement
13         {
14             get { return statement; }
15             set { statement = value; }
16         }
17         public int  Data
18         {
19             get { return data; }
20             set { data  = value; }
21         }
22     }

1     public class OneExpression : Expression
2     {
3         public override string GetPostifix()
4         {
5             return "";
6         }
7         public override int Multiplier() { return 1; }
8         public override int GetLength()
9         {
10             return 1;
11         }
12     }
13     public class TenExpression : Expression
14     {
15         public override string GetPostifix()
16         {
17             return "十";
18         }
19         public override int Multiplier() { return 10; }
20         public override int GetLength()
21         {
22             return 2;
23         }
24     }
25     public class HundredExpression : Expression
26     {
27         public override string GetPostifix()
28         {
29             return "百";
30         }
31         public override int Multiplier() { return 100; }
32         public override int GetLength()
33         {
34             return 2;
35         }
36     }
37     public class ThousandExpression : Expression
38     {
39         public override string GetPostifix()
40         {
41             return "千";
42         }
43         public override int Multiplier() { return 1000; }
44         public override int GetLength()
45         {
46             return 2;
47         }
48     }

Interpreter实现要点：
Interpreter模式的应用场合是interpreter模式应用中的难点，只有满足"业务规则频繁变化，且类似的模式不断重复出现，并且容易抽象为语法规则的问题"才适合使用Interpreter模式。
使用Interpreter模式来表示文法规则，从而可以使用面向对象技巧来方便地“扩展”文法。
Interpreter模式比较适合简单的文法表示，对于复杂的文法表示，Interpreter模式会产生比较大的类层次结构，需要求助于语法分析生成器这样的标准工具。

35解释器模式(Interpreter Pattern)相关推荐

java interpreter_解释器模式(Interpreter)Java
定义: 解释器模式(interpreter):给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子. 结构图: AbstractExpression解释器模式 ...
【白话设计模式二十二】解释器模式(Interpreter)
为什么80%的码农都做不了架构师?>>> #0 系列目录# 白话设计模式工厂模式单例模式 [白话设计模式一]简单工厂模式(Simple Factory) [白话设计模式二] ...
设计模式的理解：解释器模式 Interpreter
解释器模式(Interpreter Pattern)提供了评估语言的语法或表达式的方式,它属于行为型模式.这种模式实现了一个表达式接口,该接口解释一个特定的上下文.这种模式被用在 SQL 解析.符号处 ...
设计模式之15 - 解释器模式Interpreter
1. 解释器模式(Interpreter Pattern)的定义 (1)定义给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子. ①文法:即语法规则.在解 ...
设计模式之解释器模式(Interpreter)摘录
23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于如何创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而 ...
解释器模式(interpreter)解析例子
摘要:本文深入浅出的讲述了设计模式中的解释器模式,并给出了简单的示例,例子浅显易懂,并附带源代码. 解释器模式属于行为型模式,其意图是给定一个语言,定义它的文法表示,并定义一个解释器,这个解释器使用该 ...
行为型设计模式之解释器模式(Interpreter)
结构意图给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子. 适用性当有一个语言需要解释执行, 并且你可将该语言中的句子表示为一个抽象语法树时,可使用 ...
[设计模式-行为型]解释器模式(Interpreter)
一句话看起来是用来解释一种语言的文法.(类似不同的解释器子类解释不同的字符) 和编译器类似的解释器, 实际状况可能使用的比较少. 概括解析 INTERPRETER-俺有一个<泡MM真经> ...
设计模式循序渐进（9）解释器模式 Interpreter
通过解释器模式实现阿拉伯数字与罗马数字的相互转换. 具体的模式分析解说日后补发. Delphi代码: unit uInt2RomeInterpreter; { 单元说明:将整数转换为罗马数字 ...

35解释器模式(Interpreter Pattern)

35解释器模式(Interpreter Pattern)相关推荐

最新文章

热门文章