• 日期: 2028-02-14
  • 标签: 科技

1、设计任务与目的：

设计一个Java四则运算系统，可以实现加减乘除四种基本算术运算，可以自动生成指定数量的随机算式，支持括号运算和多级运算符优先级，保证算式的正确性，并能够输出算式和答案。目的是提高Java编程能力，加深对基本算法和数据结构的理解。

2、设计思路：

本系统采用面向对象的思想进行设计，主要包括四个类：Main类、Expression类、Operator类和Number类。其中，Main类为系统入口，负责与用户进行交互，获取用户输入的参数并生成算式；Expression类为算式类，负责生成随机算式、计算算式的值以及判断算式是否合法；Operator类为运算符类，主要包括四种基本运算符和括号运算符，负责运算符的优先级和计算；Number类为数字类，负责生成随机数字。

3、概要设计：

(1) Main类：

属性：

  • count：生成算式的数量
  • maxNum：生成的最大数字
  • minNum：生成的最小数字
  • maxLevel：生成的最大运算符级别

方法：

  • main()：程序入口，与用户进行交互，获取用户输入的参数并生成算式

(2) Expression类：

属性：

  • expression：算式的字符串表示
  • value：算式的值

方法：

  • Expression()：构造函数，生成一个随机算式
  • Expression(String exp)：构造函数，根据传入的字符串生成算式
  • getValue()：计算算式的值
  • isValid()：判断算式是否合法

(3) Operator类：

属性：

  • priority：运算符的优先级

方法：

  • operate(double a, double b)：根据运算符计算两个数的值

(4) Number类：

方法：

  • getRandomNum()：生成一个随机数

4、详细设计：

(1) Main类：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入要生成的算式数量：");
        int count = scanner.nextInt();
        System.out.print("请输入生成算式中的最大数字：");
        int maxNum = scanner.nextInt();
        System.out.print("请输入生成算式中的最小数字：");
        int minNum = scanner.nextInt();
        System.out.print("请输入生成算式中的最大运算符级别：");
        int maxLevel = scanner.nextInt();
        for (int i = 0; i < count; i++) {
            Expression expression = new Expression(maxNum, minNum, maxLevel);
            System.out.println(expression.getExpression() + " = " + expression.getValue());
        }
    }
}

(2) Expression类：

import java.util.Random;

public class Expression {
    private String expression;
    private double value;
    private static final int MAX_LEVEL = 3; // 最大运算符级别
    private static final char[] OPERATORS = {'+', '-', '*', '/'}; // 四种基本运算符
    private static final char[] BRACKETS = {'(', ')'}; // 括号运算符

    public Expression(int maxNum, int minNum, int maxLevel) {
        this.expression = generateExpression(maxNum, minNum, maxLevel);
        this.value = calculate();
    }

    public Expression(String exp) {
        this.expression = exp;
        this.value = calculate();
    }

    public double getValue() {
        return this.value;
    }

    public String getExpression() {
        return this.expression;
    }

    private String generateExpression(int maxNum, int minNum, int maxLevel) {
        StringBuilder sb = new StringBuilder();
        int level = 1;
        while (level <= MAX_LEVEL) {
            int index = new Random().nextInt(OPERATORS.length);
            char operator = OPERATORS[index];
            if (operator == '/') {
                sb.append(generateDivision(maxNum, minNum));
            } else {
                sb.append(generateSimpleExpression(maxNum, minNum));
            }
            if (level == maxLevel) {
                break;
            }
            sb.append(' ').append(operator).append(' ');
            level++;
        }
        return sb.toString();
    }

    private String generateSimpleExpression(int maxNum, int minNum) {
        int num1 = Number.getRandomNum(maxNum, minNum);
        int num2 = Number.getRandomNum(maxNum, minNum);
        char operator = OPERATORS[new Random().nextInt(OPERATORS.length - 2)];
        return String.format("%d %s %d", num1, operator, num2);
    }

    private String generateDivision(int maxNum, int minNum) {
        int num1 = Number.getRandomNum(maxNum, minNum);
        int num2 = Number.getRandomNum(maxNum, minNum);
        while (num2 == 0 || num1 % num2 != 0) {
            num1 = Number.getRandomNum(maxNum, minNum);
            num2 = Number.getRandomNum(maxNum, minNum);
        }
        return String.format("%d / %d", num1, num2);
    }

    private double calculate() {
        String[] tokens = expression.split("\\s+");
        Stack<Double> nums = new Stack<>();
        Stack<Character> ops = new Stack<>();
        for (String token : tokens) {
            if (isNumber(token)) {
                nums.push(Double.parseDouble(token));
            } else if (isOperator(token.charAt(0))) {
                char op = token.charAt(0);
                while (!ops.isEmpty() && priority(ops.peek()) >= priority(op)) {
                    nums.push(operate(nums.pop(), nums.pop(), ops.pop()));
                }
                ops.push(op);
            } else if (isLeftBracket(token.charAt(0))) {
                ops.push(token.charAt(0));
            } else if (isRightBracket(token.charAt(0))) {
                while (!isLeftBracket(ops.peek())) {
                    nums.push(operate(nums.pop(), nums.pop(), ops.pop()));
                }
                ops.pop();
            }
        }
        while (!ops.isEmpty()) {
            nums.push(operate(nums.pop(), nums.pop(), ops.pop()));
        }
        return nums.pop();
    }

    private boolean isNumber(String s) {
        return s.matches("\\d+");
    }

    private boolean isOperator(char c) {
        return c == '+' || c == '-' || c == '*' || c == '/';
    }

    private boolean isLeftBracket(char c) {
        return c == '(';
    }

    private boolean isRightBracket(char c) {
        return c == ')';
    }

    private int priority(char op) {
        if (op == '+' || op == '-') {
            return 1;
        } else if (op == '*' || op == '/') {
            return 2;
        } else {
            return 3;
        }
    }

    private double operate(double b, double a, char op) {
        switch (op) {
            case '+':
                return a + b;
            case '-':
                return a - b;
            case '*':
                return a * b;
            case '/':
                return a / b;
            default:
                throw new IllegalArgumentException("Illegal operator: " + op);
        }
    }
}

(3) Operator类：

public class Operator {
    private int priority;

    public Operator(int priority) {
        this.priority = priority;
    }

    public int getPriority() {
        return this.priority;
    }

    public double operate(double a, double b) {
        return 0;
    }
}

class AddOperator extends Operator {
    public AddOperator() {
        super(1);
    }

    public double operate(double a, double b) {
        return a + b;
    }
}

class SubOperator extends Operator {
    public SubOperator() {
        super(1);
    }

    public double operate(double a, double b) {
        return a - b;
    }
}

class MulOperator extends Operator {
    public MulOperator() {
        super(2);
    }

    public double operate(double a, double b) {
        return a * b;
    }
}

class DivOperator extends Operator {
    public DivOperator() {
        super(2);
    }

    public double operate(double a, double b) {
        return a / b;
    }
}

class LeftBracketOperator extends Operator {
    public LeftBracketOperator() {
        super(3);
    }
}

class RightBracketOperator extends Operator {
    public RightBracketOperator() {
        super(3);
    }
}

(4) Number类：

import java.util.Random;

public class Number {
    public static int getRandomNum(int maxNum, int minNum) {
        return new Random().nextInt(maxNum - minNum + 1) + minNum;
    }
}

5、软件需求：

  • JDK 8或以上
  • IDE（例如Eclipse、IntelliJ IDEA等）

6、可行性研究：

本系统的设计非常简单，所需的基本算法和数据结构也比较基础，因此实现起来较为容易，可行性较高。

7、体会与心得：

通过本次设计与实现，我更加深入地了解了Java的面向对象编程思想，学习并掌握了常用的数据结构和算法。在实现过程中，我不断地调试和优化代码，加深对语言和系统的理解，不断提高了自己的编程能力。总之，这是一次非常有收获的编程实践

java四则运算系统设计实现1、设计任务与目的2、设计思路3、概要设计 4、详细设计5、软件需求6、可行性研究 7、体会与心得

原文地址: https://www.cveoy.top/t/topic/hfeH 著作权归作者所有。请勿转载和采集!

免费AI点我,无需注册和登录