java设计并实现分层的符合单一职责原则、里氏替换原则、组合复用原则的计算器程序

本文提供一种符合单一职责原则、里氏替换原则、组合复用原则的计算器程序的设计和实现方案。该程序使用Java语言编写，实现了基本的四则运算和求幂运算，支持整数和浮点数的计算。

1. 单一职责原则

单一职责原则要求一个类只负责一个功能。在计算器程序中，我们可以将其分为三个类：输入类、计算类和输出类。

输入类负责获取用户输入的表达式并将其解析为可计算的格式，计算类负责对解析后的表达式进行计算，输出类负责将计算结果输出给用户。

2. 里氏替换原则

里氏替换原则要求父类能够被子类替换而不影响程序的正确性。在计算器程序中，我们可以将基本运算和求幂运算分别封装成两个类，并使它们继承同一个父类。这样，在实现新的运算时，只需要继承父类并重写相应的方法即可，不需要修改原有的代码。

3. 组合复用原则

组合复用原则要求尽量使用组合而不是继承来实现代码复用。在计算器程序中，我们可以将计算类和输出类作为输入类的成员变量，从而实现了代码的复用。这样，在修改计算类或输出类的时候，不会影响到输入类的实现。

下面是程序的具体实现：

输入类：

public class Input {
    private Scanner scanner;
    private Calculate calculate;
    private Output output;

    public Input() {
        scanner = new Scanner(System.in);
        calculate = new Calculate();
        output = new Output();
    }

    public void start() {
        while (true) {
            System.out.print("请输入要计算的表达式（支持 + - * / ^）：");
            String expression = scanner.nextLine();
            if (expression.equals("exit")) {
                break;
            }
            try {
                double result = calculate.calculate(expression);
                output.printResult(result);
            } catch (Exception e) {
                output.printError(e);
            }
        }
    }
}

计算类：

public class Calculate {
    public double calculate(String expression) throws Exception {
        String[] tokens = expression.split(" ");
        Stack<Double> stack = new Stack<>();
        for (String token : tokens) {
            if (isOperator(token)) {
                double num2 = stack.pop();
                double num1 = stack.pop();
                stack.push(calculate(num1, num2, token));
            } else {
                stack.push(Double.parseDouble(token));
            }
        }
        if (stack.size() != 1) {
            throw new Exception("表达式格式错误！");
        }
        return stack.pop();
    }

    private boolean isOperator(String token) {
        return token.equals("+") || token.equals("-") || token.equals("*") || token.equals("/") || token.equals("^");
    }

    private double calculate(double num1, double num2, String operator) throws Exception {
        switch (operator) {
            case "+":
                return num1 + num2;
            case "-":
                return num1 - num2;
            case "*":
                return num1 * num2;
            case "/":
                if (num2 == 0) {
                    throw new Exception("除数不能为0！");
                }
                return num1 / num2;
            case "^":
                return Math.pow(num1, num2);
            default:
                throw new Exception("运算符错误！");
        }
    }
}

输出类：

public class Output {
    public void printResult(double result) {
        System.out.println("计算结果为：" + result);
    }

    public void printError(Exception e) {
        System.out.println("计算错误：" + e.getMessage());
    }
}

基本运算类：

public class BasicOperation {
    public double calculate(double num1, double num2, String operator) throws Exception {
        switch (operator) {
            case "+":
                return num1 + num2;
            case "-":
                return num1 - num2;
            case "*":
                return num1 * num2;
            case "/":
                if (num2 == 0) {
                    throw new Exception("除数不能为0！");
                }
                return num1 / num2;
            default:
                throw new Exception("运算符错误！");
        }
    }
}

求幂运算类：

public class PowerOperation extends BasicOperation {
    @Override
    public double calculate(double num1, double num2, String operator) throws Exception {
        if (!operator.equals("^")) {
            throw new Exception("运算符错误！");
        }
        return Math.pow(num1, num2);
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        Input input = new Input();
        input.start();
    }
}