Interpreter Pattern Explained with Java Code and Real-World Scenarios

Interpreter Pattern Overview

Defines a set of custom syntax rules, splits each rule into independent expression objects, and combines them for unified parsing and evaluation. Suited for parsing custom statements, formulas, and rules.

Core purpose: decompose syntax nodes, recursively interpret expressions, and facilitate extension of custom syntax.

Typical Real‑World Scenarios

Calculator arithmetic expressions and regular‑expression parsing

Report custom formulas, payroll calculations, performance auto‑calculations

Rule engines for risk‑control decisions, promotional discount conditions, permission‑filter statements

Simple script parsing, SQL fragment parsing, underlying logic of regular‑expression engines

Low‑code platforms for visual configuration condition parsing

Java Implementation (Numeric Add/Subtract Example)

Abstract Expression Interface

public interface Expression {
    // Parse and compute, returning the result
    int interpret();
}

Terminal Expression: Number

public class NumExpression implements Expression {
    private int num;
    public NumExpression(int num) {
        this.num = num;
    }
    @Override
    public int interpret() {
        return num;
    }
}

Non‑Terminal Expressions: Add and Subtract

// Addition expression
public class AddExpression implements Expression {
    private Expression left;
    private Expression right;
    public AddExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }
    @Override
    public int interpret() {
        return left.interpret() + right.interpret();
    }
}

// Subtraction expression
public class SubExpression implements Expression {
    private Expression left;
    private Expression right;
    public SubExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }
    @Override
    public int interpret() {
        return left.interpret() - right.interpret();
    }
}

Test Calculation: 10 − 3 + 5

public class Test {
    public static void main(String[] args) {
        Expression ten = new NumExpression(10);
        Expression three = new NumExpression(3);
        Expression five = new NumExpression(5);
        Expression sub = new SubExpression(ten, three); // 10 - 3
        Expression add = new AddExpression(sub, five); // (10 - 3) + 5
        System.out.println("Expression result: " + add.interpret());
    }
}

Common Business Scenarios Summary

Fixed, decomposable syntax rules that require repeated parsing and execution

Custom calculation formulas for reports, payroll, and performance automation

Rule engines handling risk‑control decisions, promotional discount conditions, and permission filters

Simple script parsing, SQL fragment parsing, and regex implementation logic

Low‑code visual configuration condition parsing

Advantages and Disadvantages

Advantages: Hierarchical syntax decomposition; adding new operations only requires creating a new expression class.

Disadvantages: Complex expressions generate many classes; multi‑level parsing can be performance‑heavy, making the pattern unsuitable for highly complex grammars.

Conclusion

The Interpreter pattern provides a clear structure for building extensible custom language parsers, but developers should weigh its class‑explosion overhead against the simplicity it offers for modest syntactic needs.