解释器模式

基本上就是必须把元素和句子，都要是为符号。所以需要一个他们的抽象类。就可以出来解释器模式了。为什么元素和句子要一个通用意图？因为解释器的句子，可能就是某个句子的符号。 整个代码就是树结构。任何一个点都是一个树。
个人感觉，基本不会自己独立去实现这个模式，java,c#都是一种更高级语言，如果非要开启解释模式，那么肯定可以找到某一领域的库，或者干脆换个专用的语言就好了。.

//感觉解释器模式的难点在于设计解释器和匹配规则上，而不在于解释器模式。
//所以想了一个死板的规则，测试某个字符串是否是 0～9数字的四则运算，比较好操作
//文法: <expression> ::= <num><operate><num>
//<num> ::= [0~9]
//<operate> ::= +-*/
//v1.在做解释器文法这种模式之前，还是做一个更直观的非文法的版本，来看看到底区别在哪里。
//很明显，第一版的问题，在于规则 if(isNum(obj1)&&isOperate(obj2)&&isNum(obj3)) hardcode在判断逻辑中，不符合开闭原则
//v2.第二版，已经符合开闭原则，但是看了下解释器模式，还是根本上不是一个东西。解释器的目的不是符合开闭原则，开闭原则只是它的必须要满足的条件。
//解释器的模式是固定的，用来解释一整套语法规则。 终结符和非终结符都视为一个可判断的符号。所以 必须增加一个终结符和非终结符通用的抽象类。
//这样。抽象符号类，终结符号类，非终结符号类。 context(我们会设立的一个处理类).就构成了典型的解释器模式。
//个人感觉，基本不会自己独立去实现这个模式，java,c#都是一种更高级语言，如果非要开启解释模式，那么肯定可以找到某一领域的库，或者干脆换个专用的语言就好了。
//而简单的解释，用if else .类，方法。就可以。不需要一个解释器模式.
public class Interpreter
{
    public void Run()
    {
        String expression1="2+9";
        String expression2="2=9";
        String expression3="a-2";

        CheckExpression checkExpression=new CheckExpression();
        boolean res1= checkExpression.check(expression1);
        boolean res2= checkExpression.check(expression2);
        boolean res3= checkExpression.check(expression3);

        LSComponentsHelper.LS_Log.Log_INFO(res1+"."+res2+"."+res3+".");
    }

    public void Run2()
    {
        String expression1="2+9";
        String expression2="2=9";
        String expression3="a-2";

        CheckExpression2 checkExpression=new CheckExpression2();
        boolean res1= checkExpression.check(expression1);
        boolean res2= checkExpression.check(expression2);
        boolean res3= checkExpression.check(expression3);

        LSComponentsHelper.LS_Log.Log_INFO(res1+"."+res2+"."+res3+".");
    }

    public boolean isNum(String obj)
    {
        boolean res=false;
        try
        {
            Integer.parseInt(obj);
            res=true;
        } catch (NumberFormatException e)
        {
            e.printStackTrace();
        }
        return res;
    }

    public boolean isOperate(String objstr)
    {
        boolean res=false;
        if(objstr.equals("+")||objstr.equals("-")||objstr.equals("*")||objstr.equals("/"))
        {
            res=true;
        }
        return res;
    }

    //region non-interreter ,regular is with in the check logic. we need kick it out .
    public class CheckExpression
    {
        public boolean check(String expression)
        {
            boolean res=false;
            //num ope num
            String obj1=expression.substring(0,1);
            String obj2=expression.substring(1,2);
            String obj3=expression.substring(2,3);
            if(isNum(obj1)&&isOperate(obj2)&&isNum(obj3))
            {
                res=true;
            }
            return res;
        }
    }
    //endregion

    //region 符合开闭原则,并把元素的判断和整个表达式的判断，都抽象为一个符号，也就是终结符号和非终结符号，也就是可判断正确与否的符号。
    //concext class ，很多时候都喜欢叫做context ,对于中文来说，可能会理解为一个处理类。
    public class CheckExpression2
    {
        public IRegulation mIRegulation=new SimpleCaculateRegulation();
        public boolean check(String expression)
        {
            boolean res=false;
            if(mIRegulation.Check(expression))
            {
                res=true;
            }
            return res;
        }
    }

    //Expression 抽象表达式
    public interface IRegulation
    {
        public Boolean Check(String expression);
    }

    //非终结符表达式。也就是句子。不是某个不可拆分的符号。
    public class SimpleCaculateRegulation implements IRegulation
    {
        @Override
        public Boolean Check(String expression)
        {
            boolean res=false;
            String obj1=expression.substring(0,1);
            String obj2=expression.substring(1,2);
            String obj3=expression.substring(2,3);

            NumRegulation numRegulation=new NumRegulation();
            OperateRegulation operateRegulation=new OperateRegulation();

            if(numRegulation.Check(obj1)&&operateRegulation.Check(obj2)&&numRegulation.Check(obj3))
            {
                res=true;
            }
            return res;
        }
    }

    //终结符表达式,数字
    public class NumRegulation implements IRegulation
    {
        public Boolean Check(String obj)
        {
            boolean res = false;
            try
            {
                Integer.parseInt(obj);
                res = true;
            } catch (NumberFormatException e)
            {
                e.printStackTrace();
            }
            return res;
        }
    }

    //终结符表达式，符号
    public class OperateRegulation implements  IRegulation
    {
        public Boolean Check(String objstr)
        {
            boolean res = false;
            if (objstr.equals("+") || objstr.equals("-") || objstr.equals("*") || objstr.equals("/"))
            {
                res = true;
            }
            return res;
        }
    }


    //endregion

}