设计模式学习笔记--解释器模式

十六、解释器模式

解释器模式(interpreter pattern)提供了评估语言的语法或表达式的方式，通过实现接口来解释一个特定的上下文，常用语sql解析，符号处理等。
- 优点：可扩展性好、灵活，易于实现简单文法。
- 缺点：可用场景比较少，复杂文法难于维护。

实现

创建一个解释接口Expression和实现类，具体的解释规则。定义一个主要的解释器，和其他的组合表达式类。

- 创建接口

IExpression.java

/**
 * Created by lenovo on 2016/11/30 0030.
 * 解释器接口
 */
public interface IExpression {
    public boolean interpret(String context);
}

• 实现接口

TerminalExpression.java

/**
 * Created by lenovo on 2016/11/30 0030.
 * 解释器实现类
 */
public class TerminalExpression implements IExpression{
    private String data;

    public TerminalExpression(String data){
        this.data = data;
    }

    @Override
    public boolean interpret(String context) {
        if (context.contains(data)){
            return true;
        }
        return false;
    }
}

OrExpression.java

/**
 * Created by lenovo on 2016/11/30 0030.
 * OR逻辑的解释器
 */
public class OrExpression implements IExpression{
    private IExpression exp1 = null;
    private IExpression exp2 = null;

    public OrExpression(IExpression exp1,IExpression exp2){
        this.exp1 = exp1;
        this.exp2 = exp2;
    }

    @Override
    public boolean interpret(String context) {
        return exp1.interpret(context) || exp2.interpret(context);
    }
}

AndExpression.java

/**
 * Created by lenovo on 2016/11/30 0030.
 * AND逻辑的解释器
 */
public class AndExpression implements IExpression{
    private IExpression exp1 = null;
    private IExpression exp2 = null;

    public AndExpression(IExpression exp1, IExpression exp2){
        this.exp1 = exp1;
        this.exp2 = exp2;
    }

    @Override
    public boolean interpret(String context) {
        return exp1.interpret(context) && exp2.interpret(context);
    }
}

• 演示

InterpreterPatternDemo.java

/**
 * Created by lenovo on 2016/11/30 0030.
 * 解释器演示
 */
public class InterpreterPatternDemo {
    //规则，robert和john是男性
    public static IExpression getMaleExpression(){
        IExpression robert = new TerminalExpression("Robert");
        IExpression john = new TerminalExpression("John");
        return new OrExpression(robert,john);
    }
    //规则，julie 是已婚女性
    public static IExpression getMarriedWomanExpression(){
        IExpression julie = new TerminalExpression("Julie");
        IExpression married = new TerminalExpression("Married");
        return new AndExpression(julie,married);
    }
    public static void main(String[] args){
        IExpression isMale = getMaleExpression();
        IExpression isMarriedWoman = getMarriedWomanExpression();
        //就是用context的上下文，去匹配定义的规则，若满足，则是符合指令。
        System.out.println("John is male ? "+isMale.interpret("John"));
        System.out.println("Julie is a married woman ? "+isMarriedWoman.interpret("Married Julie"));
    }
}

• 输出

John is male ? true
Julie is a married woman ? true