设计模式学习之路--解释器模式

设计模式是进阶到架构师的必备技能，当然不只是记住他们的名字，而是要学会他们的精髓。这就不简单了，还是得靠经验和学习。无美女，不代码！

解释器模式使用的还是有点少，但是也是一个很重要的模式之一，在安卓源码使用的就不少了。解释器，顾名思义。就是对解释算法逻辑的封装。比如传入一串加减乘除的字符串，最后得到一个结果。使用者只关心结果，不关心中间层如何解释计算的。那么就需要对解释过程进行封装。正则表达式也是类似，这里就不介绍正则了。就举个加减乘除的解释器计算字符串“5 * 6 / 3 + 2”。

我们先简单的对运算过程进行分析。

那么我需要终结点类和非终结点类。用于接收传入的计算最小单位。还需要一个接口来获得结果。

public interface Node {
    int interpert();
}

/**
 * 终结点
 * Created by Administrator on 2017/1/7.
 */

public class EndPoint implements Node{
    protected int number;

    public EndPoint(int number) {
        this.number = number;
    }

    @Override
    public int interpert() {
        return number;
    }

}

public class NotEndPoint{

    //终结点由两个终结点计算得出
    protected Node left;
    //左右两个整数
    protected Node right;

    public NotEndPoint(Node left, Node right) {
        this.left = left;
        this.right = right;
    }
}

接下来就是写详细的算法过程。

/**
 * 加法运算
 * 
 * Created by Administrator on 2017/1/7.
 */

public class AddOperation extends NotEndPoint implements Node{
    public AddOperation(Node left, Node right) {
        super(left, right);
    }

    @Override
    public int interpert() {
        return left.interpert()+right.interpert();
    }
}

/**
 * Created by Administrator on 2017/1/7.
 */

public class DivOperation extends NotEndPoint implements Node{
    public DivOperation(Node left, Node right) {
        super(left, right);
    }

    @Override
    public int interpert() {
        return left.interpert()/right.interpert();
    }
}

public class MulOperation extends NotEndPoint implements Node{
    public MulOperation(Node left, Node right) {
        super(left, right);
    }

    @Override
    public int interpert() {
        return left.interpert()*right.interpert();
    }
}

最关键的是运算类，运算逻辑都在这里。

public class Operation implements Node {

    private String str;

    public Operation(@NonNull String str) {
        this.str = str;
    }

    @Override
    public int interpert() {
        //特殊约定，以空格作为分隔符
        String[]allStrs = str.split(" ");
        Log.i("tag00","传入的字符串："+str  +"分解之后："+allStrs.length);
        Node left = null;
        Node right = null;
        Node result = null;
        for (int position = 0; position < allStrs.length; position++) {
            switch (allStrs[position]){
                case "*":
                    left = result;
                    right = new EndPoint(Integer.parseInt(allStrs[++position]));
                    //运算之后获得非终结点
                    result = new MulOperation(left,right);
                    break;
                case "/":
                    left = result;
                    right = new EndPoint(Integer.parseInt(allStrs[++position]));
                    //运算之后获得非终结点
                    result = new DivOperation(left,right);
                    break;
                case "+":
                    left = result;
                    right = new EndPoint(Integer.parseInt(allStrs[++position]));
                    //运算之后获得非终结点
                    result = new AddOperation(left,right);
                    break;
                default:
                    result = new EndPoint(Integer.parseInt(allStrs[position]));
                    break;
            }
        }
        return result.interpert();
    }
}

然后调用

Operation operation =  new Operation("5 * 6 / 3 + 2");
        Log.i("tag00","结果："+operation.interpert());

结果就算出来了。这里面运用到了二叉树分析算法。一层一层向下递归，最后获得结果。而Operation类是整理二叉树的逻辑。这就是解析器模式的简单运用。