软件设计十七

 

 

实验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;

 

// 抽象表达式接口

interface Expression {

    String interpret();

}

 

// 方向表达式

class DirectionExpression implements Expression {

    private String direction;

 

    public DirectionExpression(String direction) {

        this.direction = direction;

    }

 

    @Override

    public String interpret() {

        switch (direction) {

            case "up":

                return "向上";

            case "down":

                return "向下";

            case "left":

                return "向左";

            case "right":

                return "向右";

            default:

                throw new IllegalArgumentException("无效的方向: " + direction);

        }

    }

}

 

// 动作表达式

class ActionExpression implements Expression {

    private String action;

 

    public ActionExpression(String action) {

        this.action = action;

    }

 

    @Override

    public String interpret() {

        switch (action) {

            case "move":

                return "移动";

            case "run":

                return "奔跑";

            default:

                throw new IllegalArgumentException("无效的动作: " + action);

        }

    }

}

 

// 距离表达式

class DistanceExpression implements Expression {

    private int distance;

 

    public DistanceExpression(int distance) {

        this.distance = distance;

    }

 

    @Override

    public String interpret() {

        return distance + "个单位";

    }

}

 

// 组合表达式

class CompositeExpression implements Expression {

    private Expression firstExpression;

    private Expression secondExpression;

 

    public CompositeExpression(Expression firstExpression, Expression secondExpression) {

        this.firstExpression = firstExpression;

        this.secondExpression = secondExpression;

    }

 

    @Override

    public String interpret() {

        return firstExpression.interpret() + "再" + secondExpression.interpret();

    }

}

 

// 上下文类，解析指令字符串

class InterpreterContext {

    private String[] tokens;

    private int currentIndex = 0;

 

    public InterpreterContext(String input) {

        this.tokens = input.split(" ");

    }

 

    public boolean hasNext() {

        return currentIndex < tokens.length;

    }

 

    public String nextToken() {

        return tokens[currentIndex++];

    }

}

 

// 客户端解析器

class InterpreterClient {

    public static Expression parse(String input) {

        InterpreterContext context = new InterpreterContext(input);

        return parseExpression(context);

    }

 

    private static Expression parseExpression(InterpreterContext context) {

        if (!context.hasNext()) {

            return null;

        }

 

        String direction = context.nextToken();

        String action = context.nextToken();

        int distance = Integer.parseInt(context.nextToken());

 

        Expression expression = new CompositeSingleExpression(

            new DirectionExpression(direction),

            new ActionExpression(action),

            new DistanceExpression(distance)

        );

 

        if (context.hasNext()) {

            String next = context.nextToken();

            if ("and".equals(next)) {

                Expression secondExpression = parseExpression(context);

                return new CompositeExpression(expression, secondExpression);

            }

        }

 

        return expression;

    }

}

 

// 单个动作组合表达式

class CompositeSingleExpression implements Expression {

    private DirectionExpression direction;

    private ActionExpression action;

    private DistanceExpression distance;

 

    public CompositeSingleExpression(DirectionExpression direction, ActionExpression action, DistanceExpression distance) {

        this.direction = direction;

        this.action = action;

        this.distance = distance;

    }

 

    @Override

    public String interpret() {

        return direction.interpret() + action.interpret() + distance.interpret();

    }

}

 

// 测试类

public class RobotInterpreter {

    public static void main(String[] args) {

        String input1 = "up move 5";

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

 

        Expression expression1 = InterpreterClient.parse(input1);

        System.out.println(expression1.interpret()); // 输出: 向上移动5个单位

 

        Expression expression2 = InterpreterClient.parse(input2);

        System.out.println(expression2.interpret()); // 输出: 向下移动10个单位再向左移动20个单位

    }

}

3. 运行结果