设计模式学习笔记——解释器(Interpreter)模式

迷南。 2022-06-17 01:55 260阅读 0赞

# 设计模式学习笔记——解释器(Interpreter)模式 #

@(设计模式)\[设计模式, 解释器模式, Interpreter\]

*  设计模式学习笔记解释器Interpreter模式
    
     *  基本介绍
     *  解释器案例
        
         *  类图
         *  实现代码
            
             *  Node抽象类
             *  ParseException类
             *  ProgramNode类
             *  CommandListNode类
             *  CommandNode类
             *  RepeatCommandNode类
             *  PrimitiveCommandNode类
             *  Context类
             *  测试类
             *  运行结果
     *  解释器模式中的角色
        
         *  AbstractExpression抽象表达式
         *  TerminalExpression终结符表达式
         *  NonterminalExpression非终结符表达式
         *  Context文脉上下文
         *  Client请求者
         *  类图

## 基本介绍 ##

给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

## 解释器案例 ##

### 类图 ###

![解释器案例类图][SouthEast]

### 实现代码 ###

#### Node抽象类 ####

package com.pc.interpreter.example;
    
    /** * 节点类 */
    public abstract class Node { 
        /** * 解析 * * @param context 上下文 * @throws ParseException 解析异常 */
        public abstract void parse(Context context) throws ParseException;
    }

#### ParseException类 ####

package com.pc.interpreter.example;
    
    /** * 解析异常类 */
    public class ParseException extends Exception { 
        public ParseException(String msg) {
            super(msg);
        }
    }

#### ProgramNode类 ####

package com.pc.interpreter.example;
    
    /** * 程序节点类 * <program> ::= program <command list> */
    public class ProgramNode extends Node { 
        /** * 命令列表节点 */
        private Node commandListNode;
    
        @Override
        public void parse(Context context) throws ParseException {
            context.skipToken("program");
            commandListNode = new CommandListNode();
            commandListNode.parse(context);
        }
    
        @Override
        public String toString() {
            return "[program " + commandListNode + "]";
        }
    }

#### CommandListNode类 ####

package com.pc.interpreter.example;
    
    import java.util.ArrayList;
    
    /** * 命令列表节点类 * <command list> ::= <command>* end */
    public class CommandListNode extends Node { 
        /** * 命令列表 */
        private ArrayList list = new ArrayList();
    
        @Override
        public void parse(Context context) throws ParseException {
            while (true) {
                if (context.currentToken() == null) {
                    throw new ParseException("Missing 'end'");
                } else if (context.currentToken().equals("end")) {
                    context.skipToken("end");
                    break;
                } else {
                    Node commandNode = new CommandNode();
                    commandNode.parse(context);
                    list.add(commandNode);
                }
            }
        }
    
        @Override
        public String toString() {
            return list.toString();
        }
    }

#### CommandNode类 ####

package com.pc.interpreter.example;
    
    /** * 命令节点类 * <command> ::= <repeat command> | <primitive command> */
    public class CommandNode extends Node { 
        /** * 节点 */
        private Node node;
    
        @Override
        public void parse(Context context) throws ParseException {
            if (context.currentToken().equals("repeat")) {
                node = new RepeatCommandNode();
                node.parse(context);
            } else {
                node = new PrimitiveCommandNode();
                node.parse(context);
            }
        }
    
        @Override
        public String toString() {
            return node.toString();
        }
    }

#### RepeatCommandNode类 ####

package com.pc.interpreter.example;
    
    /** * 重复命令节点类 * <repeat command> ::= repeat <number> <command list> */
    public class RepeatCommandNode extends Node { 
        /** * 重复次数 */
        private int number;
        /** * 命令列表节点 */
        private Node commandListNode;
    
        @Override
        public void parse(Context context) throws ParseException {
            context.skipToken("repeat");
            number = context.currentNumber();
            context.nextToken();
            commandListNode = new CommandListNode();
            commandListNode.parse(context);
        }
    
        @Override
        public String toString() {
            return "[repeat " + number + " " + commandListNode + "]";
        }
    }

#### PrimitiveCommandNode类 ####

package com.pc.interpreter.example;
    
    /** * 原始命令节点类 * <primitive command> ::= go | right | left */
    public class PrimitiveCommandNode extends Node { 
        /** * 名字 */
        private String name;
    
        @Override
        public void parse(Context context) throws ParseException {
            name = context.currentToken();
            context.skipToken(name);
            if (!name.equals("go") && !name.equals("right") && !name.equals("left")) {
                throw new ParseException(name + " is undefined");
            }
        }
    
        @Override
        public String toString() {
            return name;
        }
    }

#### Context类 ####

package com.pc.interpreter.example;
    
    
    import java.util.StringTokenizer;
    
    /** * 上下文类 */
    public class Context { 
        /** * 分词器 */
        private StringTokenizer tokenizer;
        /** * 当前符号 */
        private String currentToken;
    
        public Context(String text) {
            this.tokenizer = new StringTokenizer(text);
            this.nextToken();
        }
    
        /** * 返回下一个符号 * * @return 下一个符号 */
        public String nextToken() {
            if (tokenizer.hasMoreTokens()) {
                this.currentToken = this.tokenizer.nextToken();
            } else {
                this.currentToken = null;
            }
            return this.currentToken;
        }
    
        /** * 返回当前符号 * * @return 当前符号 */
        public String currentToken() {
            return this.currentToken;
        }
    
        /** * 跳过指定符号 * * @param token 指定符号 * @throws ParseException 解析异常 */
        public void skipToken(String token) throws ParseException {
            if (!token.equals(this.currentToken)) {
                throw new ParseException("Warning: " + token + " is expected, but " + currentToken + " is found.");
            }
            this.nextToken();
        }
    
        /** * 解析数值 * * @return 数值 * @throws ParseException 解析异常 */
        public int currentNumber() throws ParseException {
            int number = 0;
            try {
                number = Integer.parseInt(currentToken);
            } catch (NumberFormatException e) {
                throw new ParseException("Warning: " + e);
            }
            return number;
        }
    }

#### 测试类 ####

package com.pc.interpreter.example.test;
    
    import com.pc.interpreter.example.Context;
    import com.pc.interpreter.example.Node;
    import com.pc.interpreter.example.ProgramNode;
    import org.junit.Test;
    
    import java.io.BufferedReader;
    import java.io.FileReader;
    
    /** * Interpreter Tester. * * @author Switch * @version 1.0 */
    public class InterpreterTest { 
        /** * 测试解释器模式 */
        @Test
        public void testInterpreter() {
            try {
                BufferedReader reader = new BufferedReader(new FileReader(System.getProperty("user.dir")
                        + "/src/main/java/com/pc/interpreter/example/program.txt"));
                String text;
                while ((text = reader.readLine()) != null) {
                    System.out.println("text = \"" + text + "\"");
                    Node node = new ProgramNode();
                    node.parse(new Context(text));
                    System.out.println("node = " + node);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

#### 运行结果 ####

text = "program end" node = [program []] text = "program go end" node = [program [go]] text = "program go right go right go right go right end" node = [program [go, right, go, right, go, right, go, right]] text = "program repeat 4 go right end end" node = [program [[repeat 4 [go, right]]]] text = "program repeat 4 repeat 3 go right go left end right end end" node = [program [[repeat 4 [[repeat 3 [go, right, go, left]], right]]]]

## 解释器模式中的角色 ##

### AbstractExpression(抽象表达式) ###

`AbstractExpression`角色定义了语法树节点的共同接口（`API`）。在案例中，由`Node`类扮演此角色。在案例中，共同接口（`API`）的名字是`parse`，不过在类图中它的名字是`interpreter`。

### TerminalExpression(终结符表达式) ###

`TerminalExpression`角色对应`BNF`中的终结特表达式。在案例中，由`PrimitiveCommandNode`类扮演此角色。

### NonterminalExpression(非终结符表达式) ###

`NonterminalExpression`角色对应`BNF`中的非终结符表达式。在案例中，由`ProgramNode`类、`CommandNode`类、`RepeatCommandNode`类和CommandListNode 类扮演此角色。

### Context(文脉、上下文) ###

Context 角色为解释器进行语法解析提供了必要的信息。在案例中，由Context 类扮演此角色。

### Client(请求者） ###

为了推导语法树， C li ent 角色会调用TerminalExpression 角色和Nonterm inalExpress i on 角色。在案例中，由Ma 工n 类扮演此角色。

### 类图 ###

![解释器模式类图][SouthEast 1]

GitHub：[DesignPatternStudy][]

——————参考《图解设计模式》

[SouthEast]: /images/20220617/4e131597c58c405686d1383dca2c435d.png
[SouthEast 1]: /images/20220617/55d140b148274982a968c945607b8282.png
[DesignPatternStudy]: https://github.com/Switch-vov/DesignPatternStudy