解释器模式

类图：

代码：

点击查看代码

import java.util.*;

/**
 * 机器人控制程序，解释器模式实现
*/
public class RobotInterpreter {

    /* ---------- 表达式接口 ---------- */
    interface Expression {
        String interpret();
    }

    /* ---------- 终结符表达式 ---------- */
    static class DirectionExpression implements Expression {
        private final String direction;
        DirectionExpression(String direction) { this.direction = direction.toLowerCase(); }
        public String interpret() {
            switch (direction) {
                case "up": return "向上";
                case "down": return "向下";
                case "left": return "向左";
                case "right": return "向右";
                default: return direction;
            }
        }
    }

    static class ActionExpression implements Expression {
        private final String action;
        ActionExpression(String action) { this.action = action.toLowerCase(); }
        public String interpret() {
            return action.equals("run") ? "移动" : "移动";
        }
    }

    static class DistanceExpression implements Expression {
        private final int distance;
        DistanceExpression(int distance) { this.distance = distance; }
        public String interpret() { return distance + "个单位"; }
    }

    /* ---------- 非终结符表达式 ---------- */
    static class SequenceExpression implements Expression {
        private final List<Expression> list;
        SequenceExpression(List<Expression> list) { this.list = list; }
        public String interpret() {
            StringBuilder sb = new StringBuilder();
            for (Expression e : list) sb.append(e.interpret());
            return sb.toString();
        }
    }

    static class AndExpression implements Expression {
        private final Expression left, right;
        AndExpression(Expression left, Expression right) {
            this.left = left; this.right = right;
        }
        public String interpret() {
            return left.interpret() + "再" + right.interpret();
        }
    }

    /* ---------- 上下文 ---------- */
    static class Context {
        private final String[] tokens;
        private int index = 0;
        Context(String text) { tokens = text.trim().split("\\s+"); }
        boolean hasNext() { return index < tokens.length; }
        String current() { return hasNext() ? tokens[index] : null; }
        String next() { return hasNext() ? tokens[index++] : null; }
    }

    /* ---------- 解析器 ---------- */
    static class Parser {
        private Context ctx;
        Expression parse(String text) {
            ctx = new Context(text);
            return parseExpression();
        }
        private Expression parseExpression() {
            Expression dir  = new DirectionExpression(ctx.next());
            Expression act  = new ActionExpression(ctx.next());
            Expression dis  = new DistanceExpression(Integer.parseInt(ctx.next()));
            List<Expression> seq = Arrays.asList(dir, act, dis);
            Expression seqExp = new SequenceExpression(seq);

            if (ctx.hasNext() && "and".equals(ctx.current())) {
                ctx.next(); // consume "and"
                Expression next = parseExpression();
                return new AndExpression(seqExp, next);
            }
            return seqExp;
        }
    }

    /* ---------- 测试 ---------- */
    public static void main(String[] args) {
        Parser parser = new Parser();
        String[] tests = {
            "up move 5",
            "down run 10 and left move 20",
            "right run 3 and up move 2 and down run 1"
        };
        for (String t : tests) {
            System.out.println("输入：" + t);
            System.out.println("输出：" + parser.parse(t).interpret());
            System.out.println();
        }
    }
}