解释器模式

一，定义

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

常见的解释器模式比如：正则表达式，我们给定一个正则的语法表示，当我们输入一串字符串，其中的解释器就会告诉我们这段字符串是否匹配该正则表达式。

二，示例

实现一个音乐解释器。
我们的规则：
O表示音阶 “O 1”表示低音阶 ，“O 2”表示中音阶 “O 3”表示高音阶
P表示休止符
C D E F G A B表示“Do-Re-Mi-Fa-So-La-Ti”即 阿拉伯数字 1 2 3 4 5 6 7
音符长度 1 表示一拍，2表示二拍，0.5表示半拍，0.25表示四分之一拍

/**
 * @类描述：演奏内容
 */
public class PlayContext {
    private String text;

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }
}

/**
 * @类描述：表达式类
 */
public abstract class Expression {
    public void interpret(PlayContext context){
        if (context.getText().length() == 0){
            return;
        } else {
            String playKey = context.getText().substring(0,1);
            context.setText(context.getText().substring(2));
            double playValue = Double.parseDouble(context.getText().substring(0,context.getText().indexOf(" ")));
            context.setText(context.getText().substring(context.getText().indexOf(" ") + 1));
            excute(playKey,playValue);
        }
    }

    public abstract void excute(String key,double value);
}

/**
 * @类描述：音符类
 */
public class Note extends Expression {
    @Override
    public void excute(String key, double value) {
        String note = "";
        switch (key){
            case "C":
                note = "1";
                break;
            case "D":
                note = "2";
                break;
            case "E":
                note = "3";
                break;
            case "F":
                note = "4";
                break;
            case "G":
                note = "5";
                break;
            case "A":
                note = "6";
                break;
            case "B":
                note = "7";
                break;
            default:
                break;
        }
        System.out.print(note + " ");
    }
}

/**
 * @类描述：音调类
 */
public class Scale extends Expression {
    @Override
    public void excute(String key, double value) {
        String scale = "";
        switch ((int)value){
            case 1:
                scale = "低音";
                break;
            case 2:
                scale = "中音";
                break;
            case 3:
                scale = "高音";
                break;
            default:
                break;
        }
        System.out.print(scale + " ");
    }
}

/**
 * @类描述：音速类
 */
public class Speed extends Expression {
    @Override
    public void excute(String key, double value) {
        String speed = "";
        if (value < 500){
            speed = "低速";
        } else if(value >= 1000){
            speed = "慢速";
        } else {
            speed = "中速";
        }
        System.out.print(speed + " ");
    }
}

//test main
    //解释器模式
    public static void interpreterModel(){
        PlayContext context = new PlayContext();
        System.out.println("上海滩：");
        context.setText("T 500 O 2 E 0.5 G 0.5 A 3 E 0.5 G0.5 D 3 E 0.5 G 0.5 A 0.5 O 3 C 1 O 2 A 0.5 G 1 C 0.5 E 0.5 D 3 ");
        Expression expression = null;
        try {
            while (context.getText().length() > 0){
                String str = context.getText().substring(0,1);
                switch (str){
                    case "O":
                        expression = new Scale();
                        break;
                    case "T":
                        expression = new Speed();
                        break;
                    case "C":
                    case "D":
                    case "E":
                    case "F":
                    case "G":
                    case "A":
                    case "B":
                    case "P":
                        expression = new Note();
                        break;
                }
                expression.interpret(context);
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }

输出结果：
上海滩：
中速 中音 3 5 6 3 5 2 3 5 6 高音 1 中音 6 5 1 3 2

三，总结

优点：

• 容易地改变和扩展文法，因为该模式使用类来表示文法规则，你可使用继承来改变或扩展该文法，也比较容易实现文法，因为定义抽象语法树中各个节点的类的实现大体类似，这些类易于直接编写。

缺点：

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

使用场景：

• 当有一个语言需要解释执行，并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。
• 有一个简单的语法规则，比如一个sql语句，如果我们需要根据sql语句进行rm转换，就可以使用解释器模式来对语句进行解释。
• 一些重复发生的问题，比如加减乘除四则运算，但是公式每次都不同，有时是a+b-c*d，有时是a*b+c-d，等等等等个，公式千变万化，但是都是由加减乘除四个非终结符来连接的，这时我们就可以使用解释器模式。

解释器模式真的是一个比较少用的模式，因为对它的维护实在是太麻烦了，想象一下，一坨一坨的非终结符解释器，假如不是事先对文法的规则了如指掌，或者是文法特别简单，则很难读懂它的逻辑。解释器模式在实际的系统开发中使用的很少，因为他会引起效率、性能以及维护等问题。

参考：《大话设计模式》

示例代码：https://github.com/wangxp423/ExerciseDesignmodel