首页 > 代码库 > 大话设计模式_解释器模式(Java代码)

大话设计模式_解释器模式(Java代码)

2024-07-07 20:09:12   230人阅读

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

简单描述：一个AbstractExpression类，多个子类，存在一个Interpret方法，转义Context对象的信息。客户端根据信息实例化不同的Expression类，并调用其转义方法(这个过程可以使用简单工厂+反射进行)

大话设计模式中的截图：

代码例子：

假设HTML代码解释器：

(1)第一类标签<HTML>(开始)/<HEAD>(头信息)/<BODY>(网页)

(2)第二类标签<BR>(换行)<P>(一段开始)

(3)第三类标签<INPUT>(输入类型)<TEXTAREA>(文本输入框)

为了简化起见，假设得到的html源码标签都用";"分号分割开，只需要打印出标签所代表的意义即可

 Context类：

 1 package com.longsheng.interpreter;
 2 
 3 public class Context {
 4 
 5     private String htmlStr;
 6     
 7     public void setHtmlStr(String mStr) {
 8         htmlStr = mStr;
 9     }
10     
11     public String getHtmlStr() {
12         return htmlStr;
13     }
14     
15 }

AbstractExpression类：

 1 package com.longsheng.interpreter;
 2 
 3 public abstract class AbstractExpression {
 4 
 5     public void Interpret(Context mContext) {
 6         if (mContext.getHtmlStr() == null
 7                 || mContext.getHtmlStr().length() == 0) {
 8             return;
 9         }
10         int position = mContext.getHtmlStr().indexOf(‘;‘);
11         String mark = "";
12         if( position == -1 ) {
13             mark = mContext.getHtmlStr().substring(0);
14         } else {
15             mark = mContext.getHtmlStr().substring(0, position);
16         }
17         
18         mContext.setHtmlStr(mContext.getHtmlStr().substring(position + 1));
19         exceute(mark);
20     }
21 
22     public abstract void exceute(String key);
23 
24 }

FirstExpression类：

 1 package com.longsheng.interpreter;
 2 
 3 public class FirstExpression extends AbstractExpression {
 4 
 5     @Override
 6     public void exceute(String key) {
 7         switch(key) {
 8             case "HTML":
 9                 System.out.println("HTML信息");
10                 break;
11             case "HEAD":
12                 System.out.println("HEAD信息");
13                 break;
14             case "BODY":
15                 System.out.println("BODY信息");
16                 break;
17             default :
18         }
19     }
20 
21 }

SecondExpression类：

 1 package com.longsheng.interpreter;
 2 
 3 public class SecondExpression extends AbstractExpression {
 4 
 5     @Override
 6     public void exceute(String key) {
 7         switch(key) {
 8             case "BR":
 9                 System.out.println("换行");
10                 break;
11             case "P":
12                 System.out.println("一段开头");
13                 break;
14             default :
15         }
16     }
17 
18 }

ThirdExpression类：

 1 package com.longsheng.interpreter;
 2 
 3 public class ThirdExpression extends AbstractExpression {
 4 
 5     @Override
 6     public void exceute(String key) {
 7         switch(key) {
 8             case "INPUT":
 9                 System.out.println("输入");
10                 break;
11             case "TEXTAREA":
12                 System.out.println("文本区域");
13                 break;
14             default :
15         }
16     }
17 
18 }

客户端代码：

 1 package com.longsheng.interpreter;
 2 
 3 public class Client {
 4 
 5     public static void main( String args[] ) {
 6         Context mContext = new Context();
 7         AbstractExpression mExpression = null;
 8         mContext.setHtmlStr("HTML;HEAD;HEAD;BODY;P;BR;P;BR;TEXTAREA;TEXTAREA;INPUT;BODY;HTML");
 9         String mStr[] = mContext.getHtmlStr().split(";");
10         for (int i = 0; i < mStr.length; i++) {
11             switch (mStr[i]) {
12             case "HTML":
13             case "HEAD":
14             case "BODY":
15                 mExpression = new FirstExpression();
16                 break;
17             case "P":
18             case "BR":
19                 mExpression = new SecondExpression();
20                 break;
21             case "TEXTAREA":
22             case "INPUT":
23                 mExpression = new ThirdExpression();
24                 break;    
25             default:
26                 break;
27             }
28             mExpression.Interpret(mContext);
29         }
30     }
31     
32 }

运行结果：

 1 HTML信息
 2 HEAD信息
 3 HEAD信息
 4 BODY信息
 5 一段开头
 6 换行
 7 一段开头
 8 换行
 9 文本区域
10 文本区域
11 输入
12 BODY信息
13 HTML信息

如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。

使用解释器模式很容易改变和扩展文法，每个类表示一个不同的文法规则，直接继承抽象语法树即可。

解释器为文法中的每一条规则至少定义了一个类，因此包含许多规则的文法可能难以管理和维护。当文法非常复杂时，考虑使用其他技术，如语法分析程序或编译器生成器来处理。


联系
我们