大话设计模式——解释器模式

解释器模式

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

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

正则表达式就是解释器的一种应用，解释器为正则表达式定义了一个文法，如何表示一个特定的正则表达式，以及如何解释这个正则表达式。

抽象表达式

抽象表达式，声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享。

public abstract class AbstractExpression {
    public abstract void interpret(Context context);
}

终结符表达式

终结符表达式，实现与文法中的终结符相关联的解释操作。实现抽象表达式中所要求的接口，主要是一个interpret()方法。文法中每一个终结符都有一个具体终结表达式与之相对应。

public class TerminalExpression extends AbstractExpression {
    public void interpret(Context context) {
        System.out.println("终端解释器");
    }
}

非终结符表达式

非终结符表达式，为文法中的非终结符实现解释操作。对文法中每一条规则R1、R2……RN都需要一个具体的非终结符表达式类。通过实现抽象表达式的interpret()方法实现解释操作。解释操作以递归方式调用上面所提到的R1、R2、RN中各个符号的实例变量。

public class NonterminalExpression extends AbstractExpression {
    public void interpret(Context context) {
        System.out.println("非终端解释器");
    }
}

Context

包含解释器之外的一些全局信息。

public class Context {
    private String input;
    private String output;
    public String getInput() {
        return input;
    }
    public void setInput(String input) {
        this.input = input;
    }
    public String getOutput() {
        return output;
    }
    public void setOutput(String output) {
        this.output = output;
    }
}

客户端

客户端代码，构建表示该文法定义的语言中一个特定的句子的抽象语法树。调用解释操作。

public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        List<AbstractExpression> list = new ArrayList<AbstractExpression>();
        list.add(new TerminalExpression());
        list.add(new NonterminalExpression());
        list.add(new TerminalExpression());
        list.add(new TerminalExpression());
        for (AbstractExpression exp : list) {
            exp.interpret(context);
        }
    }
}

解释器模式好处

当有一个语言需要解释执行，并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。

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

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

音乐解释器

规则：
O表示音阶 O1表示低音阶 O2表示中音阶 O3表示高音阶
P表示休止符，'C D E F G A B’表示“Do-Re-Mi-Fa-So-La-Ti”
音符长度1表示一拍，2表示二拍，0.5表示半拍，0.25表示四分之一拍，以此类推
注意：所有的字母和数字都要用半角空格分开，例如上海滩歌曲的第一句，“浪奔”，可以写成“O 2 E 0.5 G 0.5 A 3”，表示中音开始，演奏的是 mi so la。

演奏内容类

public class PlayContext {
    // 演奏文本
    private String playText;

    public String getPlayText() {
        return playText;
    }

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

表达式类

public abstract class Expression {
    // 解释器
    public void interpret(PlayContext context) {
        if(context.getPlayText().length()==0) {
            return;
        } else {
            // 此方法用于将当前的演奏文本第一条命令获得命令字母和其参数值。
            // 例如“O 3 E 0.5 G 0.5 A 3”，则playKey为O，而playValue=3
            String playKey = context.getPlayText().substring(0,1);
            context.setPlayText(context.getPlayText().substring(2));
            double playValue = Double.parseDouble(context.getPlayText().substring(0,context.getPlayText().indexOf(" ")));
            // 获得playKey和playValue后将其从演奏文本中移除。
            // 例如“O 3 E 0.5 G 0.5 A 3”变成了“E 0.5 G 0.5 A 3”
            context.setPlayText(context.getPlayText().substring(context.getPlayText().indexOf(" ")+1));
            // 抽象方法“执行”，不同的文法子类，有不同的执行处理
            excute(playKey, playValue);
        }
    }
    // 执行
    public abstract void excute(String key,double value);
}

音符类(TerminalExpression)

public class Note extends Expression {

    @Override
    public void excute(String key, double value) {
        String note = "";
        switch (key) {
        case "C":
            note = "1";
            break; // 表示如果获得的key是C则演奏1(do)，如果是D则演奏2(Re)
        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;
        }
        System.out.print(note+" ");
    }

}

音阶类(TerminalExpression)

public class Scale extends Expression {

    @Override
    public void excute(String key, double value) {
        String scale = "";
        switch ((int)value) {
        case 1:
            scale = "低音";
            break; // 表示如果获得的key是O并且value是1则演奏低音，2则是中音，3则是高音
        case 2:
            scale = "中音";
            break;
        case 3:
            scale = "高音";
            break;
        }
        System.out.print(scale+" ");
    }

}

音速类(TerminalExpression)

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 + " ");
    }
}

客户端

/**
 *规则：
 * O表示音阶 O1表示低音阶 O2表示中音阶 O3表示高音阶
 * P表示休止符，'C D E F G A B'表示“Do-Re-Mi-Fa-So-La-Ti”
 * 音符长度1表示一拍，2表示二拍，0.5表示半拍，0.25表示四分之一拍，以此类推
 * 注意：所有的字母和数字都要用半角空格分开，例如上海滩歌曲的第一句，“浪奔”，可以写成“O 2 E 0.5 G 0.5 A 3”，表示中音开始，演奏的是 mi so la。
 * 
 */
public class Client {
    public static void main(String[] args) {
        PlayContext context = new PlayContext();
        // 音乐-上海滩
        System.out.println("上海滩：");
        context.setPlayText("T 500 O 2 E 0.5 G 0.5 A 3 E 0.5 G 0.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.getPlayText().length()>0) {
                String str = context.getPlayText().substring(0,1);
                switch(str) {
                case "O":expression = new Scale(); break;// 当首字段是O时，则表达式实例化为音阶
                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;  // 当首字母是CDEFGAB，以及休止符P时，则实例化音符
                }
                expression.interpret(context);
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

注：本文内容源自程杰的《大话设计模式》