Java设计模式（十五） 之行为型模式（解释器模式）

一、定义

nterpreter(解释器)模式是一种特殊的设计模式，它建立一个解释器（Interpreter），对于特定的计算机程序设计语言，用来解释预先定义的文法。简单地说，Interpreter模式是一种简单的语法解释器构架。

解释器模式属于行为模式，Gof是这样定义的：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

解释器模式需要解决的是，如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。

二、角色

• 抽象表达式(Expression)角色：声明一个所有的具体表达式角色都需要实现的抽象接口。这个接口主要是一个interpret()方法，称做解释操作。
• 终结符表达式(Terminal Expression)角色：实现了抽象表达式角色所要求的接口，主要是一个interpret()方法；文法中的每一个终结符都有一个具体终结表达式与之相对应。比如有一个简单的公式R=R1+R2，在里面R1和R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式。
• 非终结符表达式(Nonterminal Expression)角色：文法中的每一条规则都需要一个具体的非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字，比如公式R=R1+R2中，“+"就是非终结符，解析“+”的解释器就是一个非终结符表达式。
• 环境(Context)角色：这个角色的任务一般是用来存放文法中各个终结符所对应的具体值，比如R=R1+R2，我们给R1赋值100，给R2赋值200。这些信息需要存放到环境角色中，很多情况下我们使用Map来充当环境角色就足够了。

 三、场景展示

类图如下：

 定义抽象类

package com.ssy.wlj.interpreter;
/**
 * 类说明: 
 * @author happy
 * @since  2019年5月25日
 * 
 */
public abstract class AbstractNode {
    public abstract String interpret();
}

定义抽象类的实现类

package com.ssy.wlj.interpreter;
/**
 * 类说明: 
 * @author happy
 * @since  2019年5月25日
 * 
 */
public class ActionNode extends AbstractNode {
    private String action;
    public ActionNode(String a) {
        // TODO Auto-generated constructor stub
        this.action=a;
    }
    @Override
    public String interpret() {
        // TODO Auto-generated method stub
        if(action.equalsIgnoreCase("move")) {
            return "移动";
        }else if(action.equalsIgnoreCase("run")) {
            return "奔跑";
        }else {
        return "无效指令";
        }
    }

}

package com.ssy.wlj.interpreter;
/**
 * 类说明: 
 * @author happy
 * @since  2019年5月25日
 * 
 */
public class AndNode extends AbstractNode {

    private AbstractNode left;         //左表达式
    private AbstractNode right;        //右表达式
    
    public AndNode(AbstractNode l,AbstractNode r) {
        // TODO Auto-generated constructor stub
        this.left=l;
        this.right=r;
    }
    @Override
    public String interpret() {
        // TODO Auto-generated method stub
        return left.interpret()+"再"+right.interpret();
    }

}

package com.ssy.wlj.interpreter;
/**
 * 类说明: 
 * @author happy
 * @since  2019年5月25日
 * 
 */
public class DirectionNode extends AbstractNode {
    private String direction;
    public DirectionNode(String dir) {
        // TODO Auto-generated constructor stub
        this.direction=dir;
    }
    @Override
    public String interpret() {
        // TODO Auto-generated method stub
        if(direction.equalsIgnoreCase("up")) {
            return "向上";
        }else if(direction.equalsIgnoreCase("down")) {
            return "向下";
        }else if(direction.equalsIgnoreCase("left")) {
            return "向左";
        }else if(direction.equalsIgnoreCase("right")) {
            return "向右";
        }else {
            return "无效指令";
        }
        
    }

}

package com.ssy.wlj.interpreter;
/**
 * 类说明: 
 * @author happy
 * @since  2019年5月25日
 * 
 */
public class DistanceNode extends AbstractNode{
    private String distance;
    public DistanceNode(String d) {
        // TODO Auto-generated constructor stub
        this.distance=d;
    }
    @Override
    public String interpret() {
        // TODO Auto-generated method stub
        
        return distance;
    }

}

package com.ssy.wlj.interpreter;
/**
 * 类说明: 
 * @author happy
 * @since  2019年5月25日
 * 
 */
public class SentenceNode extends AbstractNode{
    private AbstractNode direction;
    private AbstractNode action;
    private AbstractNode distanc;
 
    public SentenceNode(AbstractNode direc,AbstractNode a,AbstractNode d) {
        // TODO Auto-generated constructor stub
        this.direction=direc;
        this.action=a;
        this.distanc=d;
    }
    @Override
    public String interpret() {
        // TODO Auto-generated method stub
        return direction.interpret()+action.interpret()+distanc.interpret();
    }

}

 

定义Handler

package com.ssy.wlj.interpreter;

import java.util.Stack;

/**
 * 类说明: 
 * @author happy
 * @since  2019年5月25日
 * 
 */
public class InstructionHandler {
    private AbstractNode node;
    public void Handle(String instruction) {
        //用栈来保存语法树。
        AbstractNode left=null,right=null;
        AbstractNode direction=null,action=null,distance=null;
        Stack<AbstractNode> stack = new Stack<AbstractNode>();
        
        //用空格分隔指令
        
        String[] word = instruction.split(" ");
        //循环
        for(int i=0;i<word.length;i++) {
            if(word[i].equalsIgnoreCase("and")) {
                left = (AbstractNode)stack.pop();
                String wordl=word[++i];
                direction = new DirectionNode(wordl);
                String word2 = word[++i];
                action = new ActionNode(word2);
                String word3 =word[++i];
                distance = new DistanceNode(word3);
                right = new SentenceNode(direction, action, distance);
                
            }else {
                String word1 = word[i];
                direction = new DirectionNode(word1);
                String word2 = word[++i];
                action = new ActionNode(word2);
                String word3 = word[++i];
                distance = new DistanceNode(word3);
                left= new SentenceNode(direction, action, distance);
                stack.push(left);
            }
        }
        this.node=(AbstractNode)stack.pop();
        
    }
    
    public String output() {
        String result = node.interpret();
        return result;
    }
}

编写客户端程序：

 

package com.ssy.wlj.interpreter;
/**
 * 类说明: 
 * @author happy
 * @since  2019年5月25日
 * 
 */
public class Client {
    public static void main(String[] args) {
        String instruction ="down run 10 and left move 20";
        InstructionHandler iHandler = new InstructionHandler();
        iHandler.Handle(instruction);
         String outString ;
         outString =iHandler.output();
         System.out.println(outString);
    }
}

解释器模式的优缺点及使用场景

优点：

• 易于改变和扩展文法，由于在解释器模式中使用类表示语言的文法规则，因此可以通过继承等机制来改变和扩张文法。
• 每一条文法规则都可以表示为一个类，因此可以方便地实现每一个简单的语言。
• 实现文法比较容易。

缺点:

• 对于复杂文法难以维护，再解释模式下每一条规则至少定义一个类，因此如果太复杂无法处理。
• 执行效率低，由于大量使用了循环和递归。因此再解释很复杂的句子时速度很慢

使用场景：

• 可以将一个需要解释执行的语言中的句子表示为一个抽象树。
• 一些重复出现的问题可以用简单的语言进行表达。
• 执行效率不是关键问题。