Android设计模式-解释器模式

UML关系简单介绍
UML简单使用的介绍
创建型设计模式
Android设计模式-单例模式
Android设计模式-工厂模式
Android设计模式-抽象工厂模式
Android设计模式-建造者模式
Android设计模式-原型模式
结构型设计模式
Android设计模式-代理模式
Android设计模式-装饰模式
Android设计模式-适配器模式
Android设计模式-组合模式
Android设计模式-门面模式
Android设计模式-桥接模式
Android设计模式-享元模式
行为型设计模式
Android设计模式-策略模式
Android设计模式-命令模式
Android设计模式-责任链模式
Android设计模式-模版方法模式
Android设计模式-迭代器模式
Android设计模式-观察者模式
Android设计模式-备忘录模式
Android设计模式-中介者模式
Android设计模式-访问者模式
Android设计模式-状态模式
Android设计模式-解释器模式

1.定义

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

2.解释器模式UML图

解释器模式UML图

角色介绍

• Context 环境角色 上下文环境类，包含解释器之外的全局信息
• AbstractExpression 抽象表达式 具体的解释任务由各个实现类完成
• TerminalExpression 终结符表达式 实现与文法中的元素相关联的解释操作，通常一个解释器模式只有一个终结符表达式，但有多个实例。
• NonterminalExpression 非终结符表达式 文法中的每条规则对应于一个非终结表达式，非终结表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结表达式。
  简单举例说明，例如 c=a+b,a b就是终结符表达式，+则是非终结符表达式。对应的解析a和b的解释器就是终结符表达式，解析+的解释器就是一个非终结符表达式

3.简单实现

就以一个简单的运算来做例子

3.1抽象表达式

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

3.2终结符表达式

public class VarExpression extends AbstractExpression {
    private  String key;

    public VarExpression(String key) {
        this.key = key;
    }

    @Override
    public int interpreter(Context context) {
        return context.getValue(key);
    }
}

3.3非终结符表达式

public class AddExpression extends AbstractExpression {
    private AbstractExpression left;

    private AbstractExpression right;

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

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

public class SubtractExpression extends AbstractExpression {
    private AbstractExpression left;

    private AbstractExpression right;

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

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

public class MultiplyExpression extends AbstractExpression {
    private AbstractExpression left;

    private AbstractExpression right;

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

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

public class DivisionExpression extends AbstractExpression {
    private AbstractExpression left;

    private AbstractExpression right;

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

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

3.4环境角色

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

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

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

3.5客户端调用

public class MyClass {
    public static void main(String args[]) {
        Context context = new Context();
        context.add("a", 5);
        context.add("b", 6);
        context.add("c", 7);

        VarExpression a = new VarExpression("a");
        VarExpression b = new VarExpression("b");
        VarExpression c = new VarExpression("c");
        
        AbstractExpression multiplyValue = new MultiplyExpression(a, b);
        AbstractExpression subtractValue = new SubtractExpression(a, b);
        AbstractExpression addValue = new AddExpression(subtractValue, c);
        AbstractExpression divisionValue = new DivisionExpression(multiplyValue, addValue);

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

    }
}

打印结果为

5

上述例子其实就是在做 ab/(a-b+c),放入代码中应该很容易看懂

4.总结

优点

• 良好的扩展性，修改和扩展文法规则时，只需要修改或添加对应的非终结表达式。

缺点

• 每条文法都对应解释器，类必然会很多

使用场景

• 重复发生的问题，可以使用解释器，例如四则运算，大小写转换等场景，就是不断重复的问题