2024.10.11

第三次作业(2024秋)

题量: 7 满分: 100

作答时间:2024-10-07 21:19至2024-10-11 08:00

智能分析

 

68.6分

一. 单选题（共2题，28.5分）

1. (单选题)软件工程的一个独特性是（）的变迁。

• A. 编码到测试、从测试到上线
• B. 需求到设计、从设计到实现
• C. 编码到测试、从测试到用户
• D. 分析到设计、从设计到程序

我的答案: C:编码到测试、从测试到用户;正确答案: D:分析到设计、从设计到程序;

 

0分

2. (单选题)抽象的目的是

• A. 完成类的设计
• B. 确定属性和行为的关系
• C. 获取全部实体属性
• D. 通过把相关的属性和其他不相关的属性分开

我的答案: D:通过把相关的属性和其他不相关的属性分开;正确答案: D:通过把相关的属性和其他不相关的属性分开;

 

14.3分

二. 多选题（共4题，57.2分）

3. (多选题)Java中的数据类型包括

• A. 内置类型
• B. 结构类型
• C. 外部类型
• D. 原子类型

我的答案: A:内置类型;正确答案: BD:结构类型; 原子类型;

 

0分

4. (多选题)Java中的访问权限包括：

• A. 保护
• B. 私有
• C. 公有
• D. 包

我的答案: ABCD:保护; 私有; 公有; 包;正确答案: ABCD:保护; 私有; 公有; 包;

 

14.3分

5. (多选题)面向对象中常见的类关系包括：

• A. 聚合
• B. 继承
• C. 共享
• D. 关联

我的答案: ABD:聚合; 继承; 关联;正确答案: ABD:聚合; 继承; 关联;

 

14.3分

6. (多选题)面向对象常用技术包括：

• A. 抽象
• B. 封装
• C. 继承
• D. 多态

我的答案: ABCD:抽象; 封装; 继承; 多态;正确答案: ABCD:抽象; 封装; 继承; 多态;

 

14.3分

三. 简答题（共1题，14.3分）

7. (简答题)请根据面向对象的设计思想，对加减法混合软件进行类的设计。请提交类的设计思路，包括：都需要哪些类，每个的属性和方法都包括哪些，给出类的源代码。

我的答案：

11.4分

类设计思路
Operator 类:
描述加法和减法操作。
属性:
symbol: 操作符号，"+" 或 "-"。
方法:
applyOperation: 对两个操作数进行计算，根据符号执行加法或减法。
Expression 类:
表示一个算术表达式，可以包含多个操作符和操作数。
属性:
operands: 操作数列表。
operators: 操作符列表。
方法:
evaluate: 计算表达式的值，根据操作符和操作数的顺序进行计算。
Calculator 类:
提供用户接口，允许用户输入表达式，并调用 Expression 来计算结果。
方法:
parseExpression: 从字符串解析表达式，提取操作数和操作符。
calculate: 调用 Expression.evaluate 来计算表达式的值。
类设计细节
1. Operator 类
属性: symbol 表示操作符。
方法: applyOperation 方法根据 symbol 执行相应的加法或减法。
2. Expression 类
属性: operands 保存操作数的列表，operators 保存操作符的列表。
方法: evaluate 按照加减运算的规则依次对操作数和操作符进行计算。
3. Calculator 类
方法: parseExpression 将用户输入的表达式字符串解析成操作数和操作符，calculate 调用 Expression 进行计算并返回结果。

package com.example.hbasetest;

import java.util.ArrayList;
import java.util.List;

// 操作符类
class Operator {
    private char symbol;

    public Operator(char symbol) {
        this.symbol = symbol;
    }

    // 应用操作符到两个操作数
    public int applyOperation(int operand1, int operand2) {
        switch (symbol) {
            case '+':
                return operand1 + operand2;
            case '-':
                return operand1 - operand2;
            default:
                throw new IllegalArgumentException("无效的操作符: " + symbol);
        }
    }
}

// 表达式类
class Expression {
    private List<Integer> operands;
    private List<Operator> operators;

    public Expression() {
        this.operands = new ArrayList<>();
        this.operators = new ArrayList<>();
    }

    // 添加操作数
    public void addOperand(int operand) {
        operands.add(operand);
    }

    // 添加操作符
    public void addOperator(Operator operator) {
        operators.add(operator);
    }

    // 计算表达式
    public int evaluate() {
        int result = operands.get(0);  // 初始操作数

        for (int i = 0; i < operators.size(); i++) {
            result = operators.get(i).applyOperation(result, operands.get(i + 1));
        }

        return result;
    }
}

// 计算器类
class Calculator {
    public Expression parseExpression(String expression) {
        Expression expr = new Expression();
        StringBuilder operand = new StringBuilder();

        for (char ch : expression.toCharArray()) {
            if (Character.isDigit(ch)) {
                operand.append(ch);
            } else if (ch == '+' || ch == '-') {
                expr.addOperand(Integer.parseInt(operand.toString()));
                expr.addOperator(new Operator(ch));
                operand = new StringBuilder();  // 重置操作数缓冲
            }
        }

        // 最后一个操作数
        expr.addOperand(Integer.parseInt(operand.toString()));
        return expr;
    }

    // 计算表达式
    public int calculate(String expression) {
        Expression expr = parseExpression(expression);
        return expr.evaluate();
    }

    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        String expression = "12+5-3+8";
        int result = calculator.calculate(expression);
        System.out.println("表达式 " + expression + " 的结果是: " + result);
    }
}