【设计模式】—-（19）解释器模式（行为型）-优快云博客

本文链接：https://blog.youkuaiyun.com/singit/article/details/54849572

开篇又要给自己找接口了，2号回上海，在高速上堵了 14个小时，导致没有按时更新博客，BS自己！

一、定义（概念）

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

二、适用场景

如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。

这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。而且当文法简单、效率不是关键问题的时候效果最好。

涉及角色：

　　（1）抽象表达式(Expression)角色：声明一个所有的具体表达式角色都需要实现的抽象接口。这个接口主要是一个interpret()方法，称做解释操作。

　　（2）终结符表达式(Terminal Expression)角色：实现了抽象表达式角色所要求的接口，主要是一个interpret()方法；文法中的每一个终结符都有一个具体终结表达式与之相对应。比如有一个简单的公式R=R1+R2，在里面R1和R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式。

　　（3）非终结符表达式(Nonterminal Expression)角色：文法中的每一条规则都需要一个具体的非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字，比如公式R=R1+R2中，“+"就是非终结符，解析“+”的解释器就是一个非终结符表达式。

　　（4）环境(Context)角色：这个角色的任务一般是用来存放文法中各个终结符所对应的具体值，比如R=R1+R2，我们给R1赋值100，给R2赋值200。这些信息需要存放到环境角色中，很多情况下我们使用Map来充当环境角色就足够了。

三、UML

四、代码

计算：(a*b)/(a-b+2)

public class Context
{
   private final Map<String, Integer> valueMap = new HashMap<String, Integer>();

   public void addValue(final String key, final int value)
   {
       valueMap.put(key, Integer.valueOf(value));
   }

   public int getValue(final String key)
   {
       return valueMap.get(key).intValue();
   }
}

public abstract class AbstractExpression
{
   public abstract int interpreter(Context context);
}

public class AddNonterminalExpression extends AbstractExpression
{
   private final AbstractExpression left;
   private final AbstractExpression right;

   public AddNonterminalExpression(final AbstractExpression left, final AbstractExpression right)
   {
       this.left = left;
       this.right = right;
   }

   @Override
   public int interpreter(final Context context)
   {
       return this.left.interpreter(context) + this.right.interpreter(context);
   }

}

public class DivisionNonterminalExpression extends AbstractExpression
{
   private final AbstractExpression left;
   private final AbstractExpression right;

   public DivisionNonterminalExpression(final AbstractExpression left, final AbstractExpression right)
   {
       this.left = left;
       this.right = right;
   }

   @Override
   public int interpreter(final Context context)
   {
       final int value = this.right.interpreter(context);
       if (value != 0)
       {
           return this.left.interpreter(context) / value;
       }
       return -1111;
   }

}

public class MultiplyNonterminalExpression extends AbstractExpression
{
   private final AbstractExpression left;
   private final AbstractExpression right;

   public MultiplyNonterminalExpression(final AbstractExpression left, final AbstractExpression right)
   {
       this.left = left;
       this.right = right;
   }

   @Override
   public int interpreter(final Context context)
   {
       return this.left.interpreter(context) * this.right.interpreter(context);
   }

}

public class SubtractNonterminalExpression extends AbstractExpression
{
   private final AbstractExpression left;
   private final AbstractExpression right;

   public SubtractNonterminalExpression(final AbstractExpression left, final AbstractExpression right)
   {
       this.left = left;
       this.right = right;
   }

   @Override
   public int interpreter(final Context context)
   {
       return this.left.interpreter(context) - this.right.interpreter(context);
   }
}

public class TerminalExpression extends AbstractExpression
{
   private final int i;

   public TerminalExpression(final int i)
   {
       this.i = i;
   }

   @Override
   public int interpreter(final Context context)
   {
       return this.i;
   }

}

public class Client
{
   //(a*b)/(a-b+2)
   public static void main(final String[] args)
   {
       final Context context = new Context();
       context.addValue("a", 7);
       context.addValue("b", 8);
       context.addValue("c", 2);

       final MultiplyNonterminalExpression multiplyValue = new MultiplyNonterminalExpression(new TerminalExpression(
               context.getValue("a")), new TerminalExpression(context.getValue("b")));

       final SubtractNonterminalExpression subtractValue = new SubtractNonterminalExpression(new TerminalExpression(
               context.getValue("a")), new TerminalExpression(context.getValue("b")));

       final AddNonterminalExpression addValue = new AddNonterminalExpression(subtractValue, new TerminalExpression(
               context.getValue("c")));

       final DivisionNonterminalExpression divisionValue = new DivisionNonterminalExpression(multiplyValue, addValue);

       System.out.println(divisionValue.interpreter(context));
   }
}

结果: