设计模式之解释器模式

1.解释器模式概念

        它允许为语言定义一个语法，并且可以创建一个解析器来解释该语言中的句子。这种模式主要用于解决当有一个语言需要解释执行，并且你希望将该语言中的句子表示为一个抽象语法树时。

2.解释器模式的组成

1）抽象表达式（Abstract Expression）

        定义了解释器的接口，包含了解释方法 interpret。

2）终结符表达式（Terminal Expression）

        实现与文法中的终结符相关的操作。

3）非终结符表达式（Non-Terminal Expression）

        包含对其他表达式的引用，并在解释过程中根据文法规则组合这些表达式的结果。

4）上下文（Context）

        包含解释器之外的一些全局信息，可能被各个解释器使用。

3.举个栗子

以加减乘除为例

如下图

4.代码实现

1）抽象表达式

Calculation

package org.xiji.interpreter;

/**
 * 定义计算接口
 */
public interface Calculation {

    /**
     * 计算结果
     */
    double calculate();
}

2）终结表达式

Number

package org.xiji.interpreter;

/**
 * 实现数字类
 */
public  class Number implements Calculation{
    private double number;

    public Number() {
    }

    public Number(double number) {
        this.number = number;
    }

    public double getNumber() {
        return number;
    }

    public void setNumber(double number) {
        this.number = number;
    }

    @Override
    public double calculate() {
        return number;
    }
}

3）非终结表达式

Symbols

package org.xiji.interpreter;

/**
 * 实现符号抽象类
 */
public abstract class Symbols implements Calculation{


    /**
     * 左边  右边
     *
     */
    protected Calculation left;
    protected Calculation right;

    public Symbols( Calculation left, Calculation right) {
        this.left = left;

        this.right = right;
    }

    @Override
    public abstract double calculate() ;
}

add

package org.xiji.interpreter;

public class Add extends Symbols{
    public Add(Calculation left, Calculation right) {
        super(left, right);
    }

    @Override
    public double calculate() {
        //减法
        return super.left.calculate() + super.right.calculate();
    }
}

sub

package org.xiji.interpreter;

public class Sub extends Symbols{
    public Sub(Calculation left, Calculation right) {
        super(left, right);
    }

    @Override
    public double calculate() {
        //减法
        return super.left.calculate() - super.right.calculate();
    }
}

div

package org.xiji.interpreter;

public class Div extends Symbols{
    public Div(Calculation left, Calculation right) {
        super(left, right);
    }

    @Override
    public double calculate() {
        //除法
        return super.left.calculate() / super.right.calculate();
    }
}

mul

package org.xiji.interpreter;

public class Mul extends Symbols{
    public Mul(Calculation left, Calculation right) {
        super(left, right);
    }

    @Override
    public double calculate() {
        //乘法

        return super.left.calculate() * super.right.calculate();
    }
}

4）测试类

package org.xiji.interpreter;

/**
 * 解释器模式测试
 */
public class InterpreterMain {

    public static void main(String[] args) {
        //以 1+2+3-4为例


        Sub sub = new Sub(
                new Add(
                        new Add(
                                new Number(1), new Number(2)
                        ), new Number(3)
                ), new Number(4)
        );




        double calculate = sub.calculate();
        System.out.println("1+2+3-4");
        System.out.println("( ( ( 1+2 ) + 3) + 4) ");

        System.out.println(calculate);

        //构建 2*3+6/5+3
        /**
         *  （（2*3） +（6/5） +3 ）
         */
        Add add = new Add(
                new Add(
                        new Mul(
                                new Number(2), new Number(3)
                        ),
                        new Div(
                                new Number(6), new Number(5)
                        )
                ),
                new Number(3)
        );
        System.out.println("2*3+6/5+3");
        System.out.println("（（2*3） +（6/5） +3 ）");
        System.out.println(add.calculate());
    }
}

5.运行结果