24.12.01

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

3. 注意编程规范。

 

1. 类图:

 

 

1. 源代码:

import java.util.ArrayList;

import java.util.List;

import java.util.StringTokenizer;

 

// 抽象表达式

interface Expression {

    String interpret();

}

 

// 方向表达式

class Direction implements Expression {

    private String direction;

 

    public Direction(String direction) {

        this.direction = direction;

    }

 

    @Override

    public String interpret() {

        switch (direction.toLowerCase()) {

            case "up":

                return "向上";

            case "down":

                return "向下";

            case "left":

                return "向左";

            case "right":

                return "向右";

            default:

                return "未知方向";

        }

    }

}

 

// 动作表达式

class Action implements Expression {

    private String action;

 

    public Action(String action) {

        this.action = action;

    }

 

    @Override

    public String interpret() {

        switch (action.toLowerCase()) {

            case "move":

                return "移动";

            case "run":

                return "跑动";

            default:

                return "未知动作";

        }

    }

}

 

// 距离表达式

class Distance implements Expression {

    private int distance;

 

    public Distance(int distance) {

        this.distance = distance;

    }

 

    @Override

    public String interpret() {

        return distance + "个单位";

    }

}

 

// 组合表达式

class CompositeExpression implements Expression {

    private Expression exp1;

    private Expression exp2;

 

    public CompositeExpression(Expression exp1, Expression exp2) {

        this.exp1 = exp1;

        this.exp2 = exp2;

    }

 

    @Override

    public String interpret() {

        return exp1.interpret() + "再" + exp2.interpret();

    }

}

 

// 基本表达式，包含方向、动作、距离

class BasicExpression implements Expression {

    private Expression direction;

    private Expression action;

    private Expression distance;

 

    public BasicExpression(Expression direction, Expression action, Expression distance) {

        this.direction = direction;

        this.action = action;

        this.distance = distance;

    }

 

    @Override

    public String interpret() {

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

    }

}

 

// 上下文类：负责解析指令

class InstructionHandler {

    private Expression expression;

 

    public void parse(String instruction) {

        StringTokenizer tokenizer = new StringTokenizer(instruction);

        List<String> tokens = new ArrayList<>();

 

        while (tokenizer.hasMoreTokens()) {

            tokens.add(tokenizer.nextToken());

        }

 

        // 解析第一部分指令

        Expression exp1 = new BasicExpression(new Direction(tokens.get(0)), new Action(tokens.get(1)), new Distance(Integer.parseInt(tokens.get(2))));

 

        // 检查是否有 "and"

        if (tokens.size() > 3 && tokens.get(3).equalsIgnoreCase("and")) {

            // 解析第二部分指令

            Expression exp2 = new BasicExpression(new Direction(tokens.get(4)), new Action(tokens.get(5)), new Distance(Integer.parseInt(tokens.get(6))));

            expression = new CompositeExpression(exp1, exp2);

        } else {

            expression = exp1;

        }

    }

 

    public String output() {

        return expression.interpret();

    }

}

 

// 测试类

public class Client{

    public static void main(String[] args) {

        InstructionHandler handler = new InstructionHandler();

 

        System.out.println("指令1：up move 5");

        handler.parse("up move 5");

        System.out.println("输出：" + handler.output());

 

        System.out.println("\n指令2：down run 10 and left move 20");

        handler.parse("down run 10 and left move 20");

        System.out.println("输出：" + handler.output());

    }

}