写在前面

1、基于2022级软件工程实验指导书

2、代码仅提供参考

3、如果代码不满足你的要求，请寻求其他的途径

运行环境

window11家庭版

IntelliJ IDEA 2023.2.2

jdk17.0.6

实验要求

任务：在第2章构造任务的基础上用面向对象构造技术，实现运算数、运算结果值的范围都在[0.100]的加法、减法、加减混合50道题，并尝试使用测试工具Junit。

‍‌任务构造3.1和3.2

构造任务3.1：实现BinaryOperation及其子类。

构造任务3.2：实现 Exercise 和 ExerciseSheet。

‍‌内容：在构造任务2.5基础上用面向对象构造技术，实现运算数、运算结果值的范围都在[0.100]的加法、减法、加减混合50道题

‌验证：分别输出符合要求的50道加法、减法、加减混合题个2套，美观输出。

源代码

BinaryOperation.java

import java.util.*;

//构造要求1：实现BinaryOperation及其子类
abstract class BinaryOperation {
    protected int operand1;
    protected int operand2;
    protected int result;

    public BinaryOperation() {
        // 生成操作数和计算结果
        Random rand = new Random();
        operand1 = rand.nextInt(101); // 生成0到100的随机数
        operand2 = generateOperand2();
        result = operate(operand1, operand2);
    }

    protected abstract int operate(int operand1, int operand2);

    // 生成第二个操作数
    protected abstract int generateOperand2();

    public String getExpression() {
        return operand1 + "\t" + getOperator() + "\t" + operand2 + "\t" + " = ";
    }

    protected abstract String getOperator();

    public int getResult() {
        return result;
    }
}

// 加法类
class Addition extends BinaryOperation {
    @Override
    protected int operate(int operand1, int operand2) {
        return operand1 + operand2;
    }

    @Override
    protected int generateOperand2() {
        Random rand = new Random();
        return rand.nextInt(101 - operand1); // 第二个操作数不能超过100减去第一个操作数
    }

    @Override
    protected String getOperator() {
        return " + ";
    }
}

// 减法类
class Subtraction extends BinaryOperation {
    @Override
    protected int operate(int operand1, int operand2) {
        return operand1 - operand2;
    }

    @Override
    protected int generateOperand2() {
        Random rand = new Random();
        return rand.nextInt(operand1 + 1); // 第二个操作数不能超过第一个操作数
    }

    @Override
    protected String getOperator() {
        return " - ";
    }
}

Exercise.java

//构造要求2：实现Exercise
class Exercise {
    private BinaryOperation operation;

    public Exercise(BinaryOperation operation) {
        this.operation = operation;
    }

    public String getExpression() {
        return operation.getExpression();
    }

    public int getResult() {
        return operation.getResult();
    }
}

ExerciseSheet.java

import java.util.HashSet;
import java.util.Set;

//构造要求2：实现ExerciseSheet
class ExerciseSheet {
    private Exercise[] exercises;

    public ExerciseSheet(int numExercises, Class<? extends BinaryOperation> operationType) {
        exercises = new Exercise[numExercises];
        try {
            Set<String> expressions = new HashSet<>(); // 使用集合来确保题目不重复
            for (int i = 0; i < numExercises; i++) {
                BinaryOperation operation = operationType.newInstance();
                String expression = operation.getExpression();
                // 如果集合中已经有了相同的表达式，则重新生成直到不重复为止
                while (expressions.contains(expression)) {
                    operation = operationType.newInstance();
                    expression = operation.getExpression();
                }
                expressions.add(expression);
                exercises[i] = new Exercise(operation);
            }
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public Exercise[] getExercises() {
        return exercises;
    }
}

Main.java

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        System.out.println("加法练习题：");
        printExerciseSheet(50, Addition.class, 2);

        System.out.println("减法练习题：");
        printExerciseSheet(50, Subtraction.class, 2);

        System.out.println("加减混合练习题：");
        printExerciseSheet(50, getMixedOperation(), 2);
    }

    // 生成加减混合运算练习题
    private static Class<? extends BinaryOperation> getMixedOperation() {
        Random rand = new Random();
        return rand.nextBoolean() ? Addition.class : Subtraction.class;
    }

    // 打印练习题
    private static void printExerciseSheet(int numExercises, Class<? extends BinaryOperation> operationType, int numSheets) {
        for (int i = 0; i < numSheets; i++) {
            ExerciseSheet sheet = new ExerciseSheet(numExercises, operationType);
            Exercise[] exercises = sheet.getExercises();
            System.out.println("习题集 " + (i + 1) + ":");
            for (int j = 0; j < numExercises; j++) {
                Exercise exercise = exercises[j];
                System.out.printf("%-10s", exercise.getExpression() + exercise.getResult());
                if ((j + 1) % 5 == 0) // 每行5个算式
                    System.out.println();
                else
                    System.out.print("\t\t");
            }
            System.out.println();
        }
    }
}

运行结果