Java设计模式之解释器模式剖析

后端

2023-07-01 04:45:10

解释器模式：揭秘代码中的语法魔术

在瞬息万变的软件开发领域，优雅、可维护性和可扩展性是至关重要的追求。解释器模式就是这样一种设计模式，它巧妙地解决了解析复杂语言表达式和扩展语法规则的难题。

理解解释器模式

1. 定义

解释器模式利用类来表示语言的文法规则，允许轻松更改或扩展语法。这种设计理念让复杂的语言表达变得清晰明了，增强了代码的可读性和维护性。

2. 组成结构

解释器模式由以下核心元素构成：

解释器接口： 定义解析语言表达式的通用接口，包含了解析方法和属性。
终结符表达式类： 解释器用于处理单个语法的类，这些类具体实现了解释器接口中定义的方法。
非终结符表达式类： 解释器用于处理组合语法的类，它们同样实现解释器接口，并将责任委托给终结符表达式类。
上下文： 储存解释过程中需要的额外信息，如输入字符串、解析结果等。

解释器模式的优势

可维护性： 通过将文法规则与解析逻辑分离，使其更易于维护与扩展。
灵活可变： 可以轻松增加新的解释表达式，满足不同的解析需求，符合开闭原则。
表达力强： 能够以类的方式表示复杂的语言语法，使代码更具可读性和可维护性。

Java中解释器模式实战

让我们通过一个简单的算术表达式解析器来体验解释器模式的实际应用。这个解析器可以解析简单的加减乘除运算并输出计算结果。

// 表达式接口
interface Expression {
    int interpret(Context context);
}

// 终结符表达式：数字表达式
class NumberExpression implements Expression {
    private int number;

    public NumberExpression(int number) {
        this.number = number;
    }

    @Override
    public int interpret(Context context) {
        return number;
    }
}

// 非终结符表达式：加法表达式
class AdditionExpression implements Expression {
    private Expression leftExpression;
    private Expression rightExpression;

    public AdditionExpression(Expression leftExpression, Expression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }

    @Override
    public int interpret(Context context) {
        return leftExpression.interpret(context) + rightExpression.interpret(context);
    }
}

// 非终结符表达式：减法表达式
class SubtractionExpression implements Expression {
    private Expression leftExpression;
    private Expression rightExpression;

    public SubtractionExpression(Expression leftExpression, Expression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }

    @Override
    public int interpret(Context context) {
        return leftExpression.interpret(context) - rightExpression.interpret(context);
    }
}

// 非终结符表达式：乘法表达式
class MultiplicationExpression implements Expression {
    private Expression leftExpression;
    private Expression rightExpression;

    public MultiplicationExpression(Expression leftExpression, Expression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }

    @Override
    public int interpret(Context context) {
        return leftExpression.interpret(context) * rightExpression.interpret(context);
    }
}

// 非终结符表达式：除法表达式
class DivisionExpression implements Expression {
    private Expression leftExpression;
    private Expression rightExpression;

    public DivisionExpression(Expression leftExpression, Expression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }

    @Override
    public int interpret(Context context) {
        return leftExpression.interpret(context) / rightExpression.interpret(context);
    }
}

// 上下文类
class Context {
    private String input;
    private int index;

    public Context(String input) {
        this.input = input;
        this.index = 0;
    }

    public String getInput() {
        return input;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }
}

// 解析器类
class Parser {
    private Context context;

    public Parser(String input) {
        this.context = new Context(input);
    }

    public Expression parseExpression() {
        Expression leftExpression = parseTerm();

        while (index < context.getInput().length() && (context.getInput().charAt(index) == '+' || context.getInput().charAt(index) == '-')) {
            if (context.getInput().charAt(index) == '+') {
                index++;
                Expression rightExpression = parseTerm();
                leftExpression = new AdditionExpression(leftExpression, rightExpression);
            } else if (context.getInput().charAt(index) == '-') {
                index++;
                Expression rightExpression = parseTerm();
                leftExpression = new SubtractionExpression(leftExpression, rightExpression);
            }
        }

        return leftExpression;
    }

    private Expression parseTerm() {
        Expression leftExpression = parseFactor();

        while (index < context.getInput().length() && (context.getInput().charAt(index) == '*' || context.getInput().charAt(index) == '/')) {
            if (context.getInput().charAt(index) == '*') {
                index++;
                Expression rightExpression = parseFactor();
                leftExpression = new MultiplicationExpression(leftExpression, rightExpression);
            } else if (context.getInput().charAt(index) == '/') {
                index++;
                Expression rightExpression = parseFactor();
                leftExpression = new DivisionExpression(leftExpression, rightExpression);
            }
        }

        return leftExpression;
    }

    private Expression parseFactor() {
        if (index < context.getInput().length() && Character.isDigit(context.getInput().charAt(index))) {
            int start = index;
            while (index < context.getInput().length() && Character.isDigit(context.getInput().charAt(index))) {
                index++;
            }
            int number = Integer.parseInt(context.getInput().substring(start, index));
            return new NumberExpression(number);
        }

        throw new RuntimeException("Invalid expression.");
    }
}

// 客户端
class Client {
    public static void main(String[] args) {
        String input = "2+3-4*5";
        Parser parser = new Parser(input);
        Expression expression = parser.parseExpression();
        Context context = new Context(input);
        int result = expression.interpret(context);
        System.out.println("Result: " + result);
    }
}