解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
简单描述：一个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信息
如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。
使用解释器模式很容易改变和扩展文法，每个类表示一个不同的文法规则，直接继承抽象语法树即可。
解释器为文法中的每一条规则至少定义了一个类，因此包含许多规则的文法可能难以管理和维护。当文法非常复杂时，考虑使用其他技术，如语法分析程序或编译器生成器来处理。
大话设计模式_解释器模式(Java代码),布布扣,bubuko.com
时间： 2024-12-24 05:51:33