23-解释器模式

概念

解释器模式（interpreter）, 给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
如果一种特定类型的问题发生的频率足够高，name可能就指的将该问题的各个势力标书为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题

当有一个语言需要解释执行，并且你可将改语言中的句子表示为一个抽象语法树时，可使用解释器模式
优点：可以很容易地改变和扩展文法，因为改模式使用类来表示文法规则，你可使用继承来改变或扩展该文法，也比较容易实现文法，因为定义抽象语法树中个节点的类的实现阀体类似，这些类都易于直接编写
缺点：解释器模式为文法中的每一条规则至少定义了一个类，因此包含许多规则的文法可能难以管理和维护。建议当文法非常复杂时，使用其他的技术如语法分析程序或编译器生成器来处理

例子 音乐解释器

package com.gof.interpreter;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 功能描述
 *
 * @since 2023-03-09
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class PlayContext {
    private String context;
}

package com.gof.interpreter;

/**
 * 功能描述
 *
 * @since 2023-03-09
 */
public abstract class Expression {
    public void Interpret(PlayContext context) {
        if (context.getContext().length() == 0) {
            return;
        } else {
            String playKey = context.getContext().substring(0, 1);
            String playText = context.getContext().substring(2);
            double playValue = Double.parseDouble(playText.substring(0, playText.indexOf(" ")));
            context.setContext(playText.substring(playText.indexOf(" ") + 1));
            execute(playKey, playValue);
        }
    }

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

package com.gof.interpreter;

/**
 * 功能描述
 *
 * @since 2023-03-09
 */
public class Note extends Expression {
    @Override
    public void execute(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.print(note);
    }
}

package com.gof.interpreter;

/**
 * 功能描述
 *
 * @since 2023-03-09
 */
public class Scale extends Expression {
    @Override
    public void execute(String key, double value) {
        String scale = "";
        switch ((int) value) {
            case 1:
                scale = "低音";
                break;
            case 2:
                scale = "中音";
                break;
            case 3:
                scale = "高音";
                break;
        }
        System.out.print(scale);
    }
}

package com.gof.interpreter;

/**
 * 功能描述
 *
 * @since 2023-03-09
 */
public class Client {
    public static void main(String[] args) {
        PlayContext context = new PlayContext();
        System.out.println("上海滩");
        context
            .setContext("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.getContext().length() > 0) {
                String str = context.getContext().substring(0, 1);
                switch (str) {
                    case "O":
                        expression = new Scale();
                        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 ex) {
            System.out.println(ex.getMessage());
        }
    }
}