设计模式（11）--解释器模式

• 计算模型按正常算数方式书写，解释器处理语法逻辑

• 计算模型里有两类符号：数据和计算符（语法规则）

• 用逆波兰算法分析算式语法

• 用解释器模式处理数组，使用了什么数据处理和什么数理逻辑

• 解释器模式：定义一个语法，定义一个解释器，该解释器处理该语法句子，将某些复杂的问题表达成某种语法规则，然后构建解释器来处理这类句子

• 代码解析：

package Jishiqimoshi;


import java.util.HashMap;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-08
* Time: 16:20
*/


/**
* 抽象表达式，解析的超类
*/
public abstract class AbstractExpresstion {
    /**插入的是一条数据
     * @param var
     * @return
     */
    public abstract Float interpreter(HashMap<String, Float> var);
}

package Jishiqimoshi;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-08
* Time: 16:24
*/


import java.util.HashMap;


/**
* 变量表达式，和字段对应
*/
public class VarExpresstion extends AbstractExpresstion{
    private String key;
    public VarExpresstion(String key){
        this.key = key;
    }


    /**
     * 传入键的参数，返回数值
     * @param var
     * @return
     */
    @Override
    public Float interpreter(HashMap<String, Float> var) {
        return var.get(this.key);
    }
}

package Jishiqimoshi;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-08
* Time: 16:27
*/


/**
* 加减乘除的一个抽象，可以分为左右两个表达式
*/
public abstract class SymbolExpresstion extends AbstractExpresstion{
    protected  AbstractExpresstion left;
    protected  AbstractExpresstion right;


    public SymbolExpresstion(AbstractExpresstion left, AbstractExpresstion right){
        this.left = left;
        this.right = right;
    }


}

• 运算符定义

package Jishiqimoshi;


import java.util.HashMap;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-08
* Time: 16:29
*/
public class MultiExpresstion extends SymbolExpresstion {
    
    public MultiExpresstion(AbstractExpresstion left, AbstractExpresstion right){
        super(left, right);
    }
    @Override
    public Float interpreter(HashMap<String, Float> var) {
        return super.left.interpreter(var) * super.right.interpreter(var);
    }
}


package Jishiqimoshi;


import java.util.HashMap;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-08
* Time: 16:31
*/
public class AddExpresstion extends SymbolExpresstion{
    public AddExpresstion(AbstractExpresstion left, AbstractExpresstion right){
        super(left, right);
    }
    @Override
    public Float interpreter(HashMap<String, Float> var) {
        return super.left.interpreter(var) + super.right.interpreter(var);
    }
}



package Jishiqimoshi;


import java.util.HashMap;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-08
* Time: 16:31
*/
public class SubExpresstion extends SymbolExpresstion {
    public SubExpresstion(AbstractExpresstion left, AbstractExpresstion right){
        super(left, right);
    }
    @Override
    public Float interpreter(HashMap<String, Float> var) {
        return super.left.interpreter(var) - super.right.interpreter(var);
    }
}



package Jishiqimoshi;


import java.util.HashMap;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-08
* Time: 16:32
*/
public class DivExpresstion extends SymbolExpresstion {
    public DivExpresstion(AbstractExpresstion left, AbstractExpresstion right){
        super(left, right);
    }
    @Override
    public Float interpreter(HashMap<String, Float> var) {
        return super.left.interpreter(var) / super.right.interpreter(var);
    }
}

• 逆波兰

package Jishiqimoshi;


import java.util.*;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-08
* Time: 16:32
*/
public class RPN {
    private ArrayList<String> expression = new ArrayList<String>();
    private ArrayList<String> right = new ArrayList<String>();
    private AbstractExpresstion result;
    // 依据输入信息创建对象，将数值与操作符放入ArrayList中
    public RPN(String input) {
        StringTokenizer st = new StringTokenizer(input, "+-*/()", true);
        while (st.hasMoreElements()) {
            expression.add(st.nextToken());
        }
    }


    // 将中序表达式转换为右序表达式
    private void toRight() {
        Stacks aStack = new Stacks();
        String operator;
        int position = 0;
        while (true) {
            if (Calculate.isOperator((String) expression.get(position))) {
                if (aStack.top == -1
                        || ((String) expression.get(position)).equals("(")) {
                    aStack.push(expression.get(position));
                } else {
                    if (((String) expression.get(position)).equals(")")) {
                        if (!((String) aStack.top()).equals("(")) {
                            operator = (String) aStack.pop();
                            right.add(operator);
                        }
                    } else {
                        if (Calculate.priority((String) expression
                                .get(position)) <= Calculate
                                .priority((String) aStack.top())
                                && aStack.top != -1) {
                            operator = (String) aStack.pop();
                            if (!operator.equals("(")) {
                                right.add(operator);
                            }
                        }
                        aStack.push(expression.get(position));
                    }
                }
            } else {
                right.add(expression.get(position));
            }
            position++;
            if (position >= expression.size()){
                break;}
        }
        while (aStack.top != -1) {
            operator = (String) aStack.pop();
            right.add(operator);
        }
    }


    // 对右序表达式进行求值
    public void getResult(HashMap<String, Float> var) {
        this.toRight();
        Stack<AbstractExpresstion> stack = new Stack<AbstractExpresstion>();
        AbstractExpresstion op1, op2;
        String is = null;
        Iterator it = right.iterator();


        while (it.hasNext()) {
            is = (String) it.next();
            if (Calculate.isOperator(is)) {
                op2 = stack.pop();
                op1 = stack.pop();
                stack.push(Calculate.twoResult(is, op1, op2));
            } else {
                stack.push(new VarExpresstion(is));
            }
        }
        result = stack.pop();
        it = expression.iterator();
        while (it.hasNext()) {
            System.out.print((String) it.next());
        }
        System.out.println("=" + result.interpreter(var));
    }


    public static class Calculate {
        // 判断是否为操作符号
        public static boolean isOperator(String operator) {
            if (operator.equals("+") || operator.equals("-")
                    || operator.equals("*") || operator.equals("/")
                    || operator.equals("(") || operator.equals(")")) {
                return true;
            }else {
                return false;
            }
        }


        // 设置操作符号的优先级别
        public static int priority(String operator) {
            if (operator.equals("+") || operator.equals("-")
                    || operator.equals("(")){
                return 1;}
            else if (operator.equals("*") || operator.equals("/")){
                return 2;}
            else{
                return 0;}
        }


        // 做2值之间的计算
        public static AbstractExpresstion twoResult(String op,
                                                    AbstractExpresstion a, AbstractExpresstion b) {
            try {


                AbstractExpresstion result = null;
                if (op.equals("+")) {
                    result = new AddExpresstion(a, b);
                }
                else if (op.equals("-")) {
                    result = new SubExpresstion(a, b);
                }
                else if (op.equals("*")){
                    result = new MultiExpresstion(a, b);}
                else if (op.equals("/")){
                    result = new DivExpresstion(a, b);}
                else{}
                    ;
                return result;
            } catch (NumberFormatException e) {
                System.out.println("input has something wrong!");
                return null;
            }
        }
    }


    // 栈类
    public class Stacks {
        private LinkedList list = new LinkedList();
        int top = -1;


        public void push(Object value) {
            top++;
            list.addFirst(value);
        }


        public Object pop() {
            Object temp = list.getFirst();
            top--;
            list.removeFirst();
            return temp;


        }


        public Object top() {
            return list.getFirst();
        }
    }
}

• 计算：

package Jishiqimoshi;


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Calendar;
import java.util.HashMap;


/**
* Created with IntelliJ IDEA.
* Description:
* User: wjx
* Date: 2019-05-08
* Time: 16:39
*/
public class Calculator {
    public Calculator() {
        float[][] dataSource = new float[3][6];
        for (int i = 0; i<3;i++){
            for(int j = 0;j<6;j++){
                dataSource[i][j] = (float)(Math.random()*100);
                System.out.println(dataSource[i][j]+",");
            }
            System.out.println(",");
        }
        try{
            System.out.println("input a expression:");
            BufferedReader is = new BufferedReader(new InputStreamReader(
                    System.in));
            for(;;){
                String input = new String();
                input = is.readLine().trim();
                if(input.equals("q")){
                    break;
                }
                else{
                    RPN boya = new RPN(input);
                    HashMap<String, Float> var;
                    for(int i = 0;i<3;i++){
                        var = new HashMap<String, Float>();
                        var.put("a", dataSource[i][0]);
                        var.put("b", dataSource[i][1]);
                        var.put("c", dataSource[i][2]);
                        var.put("d", dataSource[i][3]);
                        var.put("e", dataSource[i][4]);
                        var.put("f", dataSource[i][5]);


                        boya.getResult(var);


                    }
                }
                System.out
                        .println("Input another expression or input 'q' to quit:");
            }
            is.close();
        }catch (IOException e){
            System.out.println("Wrong input!!!");
        }
    }
}