大三打卡（10.23）

实验17：解释器模式（选作）

本次实验属于模仿型实验，通过本次实验学生将掌握以下内容：

1、理解解释器模式的动机，掌握该模式的结构；

2、能够利用解释器模式解决实际问题。

 

[实验任务一]：解释器模式

某机器人控制程序包含一些简单的英文指令，其文法规则如下：

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.     提交源代码；

import java.util.ArrayList;

import java.util.List;

 

// 抽象表达式类

abstract class Expression {

    abstract String interpret(Context context);

}

 

// 终结符表达式类

abstract class TerminalExpression extends Expression {

}

 

// 非终结符表达式类

abstract class NonTerminalExpression extends Expression {

}

 

// 方向表达式类

class DirectionExpression extends TerminalExpression {

    private String direction;

 

    public DirectionExpression(String direction) {

        this.direction = direction;

    }

 

    @Override

    String interpret(Context context) {

        return direction;

    }

}

 

// 动作表达式类

class ActionExpression extends TerminalExpression {

    private String action;

 

    public ActionExpression(String action) {

        this.action = action;

    }

 

    @Override

    String interpret(Context context) {

        return action;

    }

}

 

// 距离表达式类

class DistanceExpression extends TerminalExpression {

    private int distance;

 

    public DistanceExpression(int distance) {

        this.distance = distance;

    }

 

    @Override

    String interpret(Context context) {

        return Integer.toString(distance);

    }

}

 

// 复合表达式类

class CompositeExpression extends NonTerminalExpression {

    private List<Expression> expressions = new ArrayList<>();

 

    public void addExpression(Expression expression) {

        expressions.add(expression);

    }

 

    @Override

    String interpret(Context context) {

        StringBuilder result = new StringBuilder();

        for (Expression expression : expressions) {

            result.append(expression.interpret(context));

        }

        return result.toString();

    }

}

 

// 上下文类

class Context {

    private String instructions;

    private int index;

 

    public Context(String instructions) {

        this.instructions = instructions;

        this.index = 0;

    }

 

    public String getInstruction() {

        return instructions.substring(index).trim();

    }

 

    public int getIndex() {

        return index;

    }

 

    public void setIndex(int index) {

        this.index = index;

    }

}

 

// 客户端代码

public class InterpreterPatternDemo {

    public static void main(String[] args) {

        String command1 = "up move 5";

        String command2 = "down run 10 and left move 20";

 

        Context context1 = new Context(command1);

        Context context2 = new Context(command2);

 

        Expression expression1 = getExpression(command1);

        Expression expression2 = getExpression(command2);

 

        System.out.println(expression1.interpret(context1));

        System.out.println(expression2.interpret(context2));

    }

 

    private static Expression getExpression(String command) {

        // 这里应该包含解析命令字符串并构建表达式树的逻辑

        // 为了简化，这里直接返回一个复合表达式

        CompositeExpression composite = new CompositeExpression();

        // 假设命令总是以 "direction action distance" 的格式出现

        String[] parts = command.split(" ");

        if (parts.length >= 4) {

            composite.addExpression(new DirectionExpression(parts[0]));

            composite.addExpression(new ActionExpression(parts[1]));

            composite.addExpression(new DistanceExpression(Integer.parseInt(parts[2])));

        }

        if (command.contains("and")) {

            // 处理 "and" 逻辑

        }

        return composite;

    }

}

3. 注意编程规范。