大话设计模式之解释器模式总结-java实现

注：示例来自《大话设计模式》

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

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

下面我们来做个小型的音乐解释器程序 代码如下

演奏内容类

package Test27;

//演奏内容
public class PlayContext {

    //演奏文本
    private String text;

    public String getText() {
        return text;
    }

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

}

表达式类

package Test27;

//表达式
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);

}

音符类

package Test27;

//音符
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;
        }
        System.out.println(note);
    }

}

音阶类

package Test27;

//音阶
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;

        }
        System.out.println(scale);
    }

}

音速类

package Test27;

//音速
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.println(speed);

    }

}

客户端代码

package Test27;

public class Program {

    public static void main(String[] args) {

        PlayContext context = new PlayContext();
        //音乐-上海滩
        System.out.println("上海滩：");
        context.setText("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.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)
        {
            System.out.println(e.getMessage());
        }

    }

}

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

扫描二维码关注公众号，回复： 3162686 查看本文章

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

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