【设计模式】—-（19）解释器模式（行为型）

开篇又要给自己找接口了，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));

    }

}

结果:

56

五、总结（优点与缺点）

优点：

1）易于改变和扩展方法

2）易于实现方法

3）增加了新的解释表达式的方法

缺点：

4）复杂的方法难以维护

注意事项

       解释器模式真的是一个比较少用的模式，因为对它的维护实在是太麻烦了，想象一下，一坨一坨的非终结符解释器，假如不是事先对文法的规则了如指掌，或者是文法特别简单，则很难读懂它的逻辑。解释器模式在实际的系统开发中使用的很少，因为他会引起效率、性能以及维护等问题。