11.29

[实验任务一]：解释器模式
某机器人控制程序包含一些简单的英文指令，其文法规则如下：
expression ::= direction action distance | composite
composite ::= expression and expression
direction ::= ‘up’ | ‘down’ | ‘left’ | ‘right’
action ::= ‘move’ | ‘run’
distance ::= an integer //一个整数值
如输入：up move 5，则输出“向上移动5个单位”；输入：down run 10 and left move 20，则输出“向下移动10个单位再向左移动20个单位”。
实验要求：

1. 提交类图；
   

2. 提交源代码；

// Context.java
package interpreter;

public class Context {
    private String direction;
    private String action;
    private int distance;
    
    public void setDirection(String direction) {
        this.direction = direction;
    }
    
    public void setAction(String action) {
        this.action = action;
    }
    
    public void setDistance(int distance) {
        this.distance = distance;
    }
    
    public String getDirection() {
        return direction;
    }
    
    public String getAction() {
        return action;
    }
    
    public int getDistance() {
        return distance;
    }
}

// AbstractExpression.java
package interpreter;

public abstract class AbstractExpression {
    public abstract String interpret(Context context);
}

// DirectionExpression.java
package interpreter;

public class DirectionExpression extends AbstractExpression {
    private String direction;
    
    public DirectionExpression(String direction) {
        this.direction = direction;
    }
    
    @Override
    public String interpret(Context context) {
        context.setDirection(direction);
        switch (direction) {
            case "up": return "向上";
            case "down": return "向下";
            case "left": return "向左";
            case "right": return "向右";
            default: return "";
        }
    }
}

// ActionExpression.java
package interpreter;

public class ActionExpression extends AbstractExpression {
    private String action;
    
    public ActionExpression(String action) {
        this.action = action;
    }
    
    @Override
    public String interpret(Context context) {
        context.setAction(action);
        return action.equals("move") ? "移动" : "跑动";
    }
}

// DistanceExpression.java
package interpreter;

public class DistanceExpression extends AbstractExpression {
    private int distance;
    
    public DistanceExpression(int distance) {
        this.distance = distance;
    }
    
    @Override
    public String interpret(Context context) {
        context.setDistance(distance);
        return distance + "个单位";
    }
}

// CommandExpression.java
package interpreter;

public class CommandExpression extends AbstractExpression {
    private AbstractExpression direction;
    private AbstractExpression action;
    private AbstractExpression distance;
    
    public CommandExpression(String direction, String action, int distance) {
        this.direction = new DirectionExpression(direction);
        this.action = new ActionExpression(action);
        this.distance = new DistanceExpression(distance);
    }
    
    @Override
    public String interpret(Context context) {
        return direction.interpret(context) + 
               action.interpret(context) + 
               distance.interpret(context);
    }
}

// CompositeExpression.java
package interpreter;

public class CompositeExpression extends AbstractExpression {
    private AbstractExpression expr1;
    private AbstractExpression expr2;
    
    public CompositeExpression(AbstractExpression expr1, AbstractExpression expr2) {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }
    
    @Override
    public String interpret(Context context) {
        return expr1.interpret(context) + "再" + expr2.interpret(context);
    }
}

// RobotCommandInterpreter.java
package interpreter;

public class RobotCommandInterpreter {
    public static AbstractExpression parse(String command) {
        String[] parts = command.split(" and ");
        
        if (parts.length > 1) {
            // 复合表达式
            AbstractExpression expr1 = parseSimpleCommand(parts[0]);
            AbstractExpression expr2 = parseSimpleCommand(parts[1]);
            return new CompositeExpression(expr1, expr2);
        } else {
            // 简单表达式
            return parseSimpleCommand(command);
        }
    }
    
    private static AbstractExpression parseSimpleCommand(String command) {
        String[] tokens = command.trim().split(" ");
        if (tokens.length != 3) {
            throw new RuntimeException("Invalid command format");
        }
        
        String direction = tokens[0];
        String action = tokens[1];
        int distance = Integer.parseInt(tokens[2]);
        
        return new CommandExpression(direction, action, distance);
    }
}

// Main.java
package interpreter;

public class Main {
    public static void main(String[] args) {
        Context context = new Context();
        
        // 测试简单命令
        String command1 = "up move 5";
        AbstractExpression expr1 = RobotCommandInterpreter.parse(command1);
        System.out.println(expr1.interpret(context));
        
        // 测试复合命令
        String command2 = "down run 10 and left move 20";
        AbstractExpression expr2 = RobotCommandInterpreter.parse(command2);
        System.out.println(expr2.interpret(context));
    }
}

3. 注意编程规范。