JAVA设计模式(23)行为型-迭代器模式

长春小霸王

于 2021-10-16 19:00:46 发布

阅读量85

点赞数

CC 4.0 BY-SA版权

分类专栏：设计模式文章标签： java

本文链接：https://blog.youkuaiyun.com/jbossjf/article/details/120784788

设计模式专栏收录该内容

22 篇文章

订阅专栏

该博客介绍了如何使用解析器模式设计一个简单的计算器。它包括了表达式接口、变量表达式、加法和减法操作符表达式，以及一个计算器类来解析和计算用户输入的表达式。用户可以输入包含变量和基本算术运算的表达式，程序会根据输入的变量值进行计算。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

解析器模式是一种行为型设计模式。其思想是：给定一个语言, 定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

//@author： v: jbossjf
public interface Expression {
    double interpreter(HashMap<String, Double> var); // 声明一个解析操作
}

public class VarExp implements Expression {
    private String value;

    public VarExp(String value) {
        this.value = value;
    }

    @Override
    public double interpreter(HashMap<String, Double> var) {
        return var.get(this.value); // 返回表达式所对应的值
    }
}

public abstract class SymbolExp implements Expression {
    protected Expression left;  // 运算符左侧的表达式
    protected Expression right; // 运算符右侧的表达式

    public SymbolExp(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }
}

// 加法
public class Add extends SymbolExp {
    public Add(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public double interpreter(HashMap<String, Double> var) {
        return left.interpreter(var) + right.interpreter(var); // 返回左右两个表达式之和
    }
}

// 减法
public class Minus extends  SymbolExp {
    public Minus(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public double interpreter(HashMap<String, Double> var) {
        return left.interpreter(var) - right.interpreter(var); // 返回左右两个表达式之差
    }
}

public class Calculator {
    private Expression expression;

    public Calculator(String exp) {
        Expression left;
        Expression right;
        Stack<Expression> stack = new Stack<>();
        char[] chars = exp.toCharArray();
        for (int i = 0, len = chars.length; i < len; i++) {
            switch (chars[i]) {
                case '+':
                    left = stack.pop();                             // 从栈中取回上一个压入的元素作为左侧表达式
                    right = new VarExp(String.valueOf(chars[++i])); // 指针后移一位得到右侧表达式
                    stack.push(new Add(left, right));               // 将计算结果压回栈中
                    break;
                case '-':
                    left = stack.pop();
                    right = new VarExp(String.valueOf(chars[++i]));
                    stack.push(new Minus(left, right));
                    break;
                default:
                    // 如果是非运算符，则生成一个非终结表达式，然后压和栈中
                    stack.push(new VarExp(String.valueOf(chars[i]))); 
                    break;
            }
        }
        this.expression = stack.pop(); // 遍历完成后取回栈中的元素
    }

    // 实际上，计算已经在构造器里完成了，这里只是取回结果的值
    public double cal(HashMap<String, Double> var) {
        return this.expression.interpreter(var);
    }
}

public class Client {
    // 运行程序
    public void run() {
        String exp = getExp();
        HashMap<String, Double> var = getValues(exp);
        Calculator calculator = new Calculator(exp);
        System.out.printf("%s = %f", exp, calculator.cal(var));
    }

    // 要求用户输入表达式
    private String getExp() {
        Scanner sc = new Scanner(System.in);
        System.out.println("please defined an expression:");
        return sc.nextLine();
    }

    // 要求用户输入每个变量的值
    private HashMap<String, Double> getValues(String exp) {
        HashMap<String, Double> map = new HashMap<>();
        Scanner sc = new Scanner(System.in);
        char[] chars = exp.toCharArray();
        for (char c : chars) {
            String str = String.valueOf(c);
            if (!"+-".contains(str) && !map.containsKey(str)) {
                System.out.printf("%s = ", str);
                map.put(str, sc.nextDouble());
            }
        }
        return map;
    }
}

// 测试
class Test {
    public static void main(String[] args) {
        Client client = new Client();
        client.run();
    }
}



please defined an expression:
a+b-c+b
a = 3
b = 2
c = 1
a+b-c+b = 6.000000