1 软件开发概述测验

1、单选题：
‌计算机程序（简称程序）是为了解决某个特定问题而用程序设计语言描述的适合计算机处理的（    ）。‍
选项：
A: 函数
B: 语句序列
C: 模块
D: 问题
答案: 【 语句序列】

2、单选题：
‌软件是能够完成预定功能和性能的可执行的程序和使程序正常执行所需要的数据，加上描述软件开发过程及其管理、程序的操作和使用的有关文档，即“软件=程序+数据+（    ）‏
选项：
A: 注释
B: 文档
C: 第三方库
D: 算法
答案: 【 文档】

3、单选题：
‏软件按其功能划分为三种类型：（    ）、支撑软件和应用软件。‎
选项：
A: 娱乐软件
B: 批处理软件
C: 音乐软件
D: 系统软件
答案: 【 系统软件】

4、单选题：
‏软件按其工作方式划分为：实时处理软件、分时软件、（    ）和批处理软件。‎
选项：
A: 系统软件
B: 应用软件
C: 支撑软件
D: 交互式软件
答案: 【 交互式软件】

5、单选题：
​软件按服务对象的范围划分为：项目软件（定制开发）和（    ）（或通用软件）。‏
选项：
A: 批处理软件
B: 产品软件
C: 系统软件
D: 交互式软件
答案: 【 产品软件】

6、单选题：
‎软件的其他分类包括商业软件、（    ）、共享软件等。‍
选项：
A: 系统软件
B: 应用软件
C: 开源软件
D: 私人软件
答案: 【 开源软件】

7、单选题：
​从用户的角度，软件生存周期分为下列三个阶段:（    ）、获取软件、使用软件。‎
选项：
A: 设计软件
B: 测试软件
C: 维护
D: 提出需求
答案: 【 提出需求】

8、单选题：
‎从软件开发者的角度，一般把软件生存周期分为定义软件、开发软件和（    ）三个阶段。​
选项：
A: 测试软件
B: 维护软件
C: 总体设计
D: 详细设计
答案: 【 维护软件】

9、单选题：
​软件设计是给出如何实现需求的决策和方案，是将系统功能分配到系统不同组成元素的过程，包括一组活动①划分需求②确定子系统③给子系统分配需求④定义子系统的功能⑤（    ）。‍
选项：
A: 定义子系统接口
B: 划分子系统
C: 维护子系统
D: 测试子系统
答案: 【 定义子系统接口】

10、单选题：
‌软件实现与通常的程序设计的主要区别是（    ）。‎
选项：
A: 数据结构
B: 软件的集成与测试
C: 算法
D: 代码格式标准
答案: 【 软件的集成与测试】

11、单选题：
‌软件集成指的是通过（    ）、消息传递、事件响应、状态改变、服务合成等机制把编程实现的各个软件单元组装在一起，形成一个更大的软件单元或可以运行的软件系统。‏
选项：
A: 统一化
B: 标准化
C: 函数调用
D: 模块化
答案: 【 函数调用】

12、单选题：
‏软件测试也属于实现阶段的活动，可以分为对程序基本组成单元的测试（单元测试）对软件组装结果的测试（    ）、对整个软件系统的测试（系统测试），以及把软件交付给用户时的测试（验收测试）‍
选项：
A: 白盒测试
B: 黑盒测试
C: 回归测试
D: 集成测试
答案: 【 集成测试】

13、单选题：
‍软件维护分为4 种类型:改正性维护、（    ）、完善性维护、预防性维护。‏
选项：
A: 适应性维护
B: 测试性维护
C: 可理解性维护
D: 兼容性维护
答案: 【 适应性维护】

14、单选题：
‌预防性维护是为改善软件系统的（    ），也为以后的改进奠定基础。‍
选项：
A: 可理解性
B: 可用性
C: 可维护性和可靠性
D: 可移植性
答案: 【 可维护性和可靠性】

15、单选题：
‍软件可维护性可通过三个质量特性来衡量：（    ）、可测试性、可修改性。​
选项：
A: 可理解性
B: 可读性
C: 可移植性
D: 可用性
答案: 【 可理解性】

16、单选题：
‍瀑布式软件开发过程把软件开发分为制定计划、需求分析、软件设计、程序编写、（      ）和运行维护等6 个基本活动，并且规定了它们自上而下、相互衔接的固定次序，如同瀑布流水，逐级下落。‎
选项：
A: 用户评价
B: 软件测试
C: 设计者评价
D: 项目经理评价
答案: 【 软件测试】

17、单选题：
‌增量开发是指待开发的软件不是一次就完成的，而是把软件分成一系列（      ），完成一部分就交付一部分。‎
选项：
A: 代码组
B: 函数
C: 增量
D: 模块
答案: 【 增量】

18、单选题：
‏PSP（Personal Software Process）能够说明个体软件过程的原则；帮助软件工程师做出准确的计划；确定软件工程师为改善产品质量要采取的步骤；（      ）；确定过程的改变对软件工程师能力的影响。​
选项：
A: 建立度量个体软件过程改善的基准
B: 确定工程师的编码风格
C: 确定工程师软件测试步骤
D: 建立合理的软件评估方案
答案: 【 建立度量个体软件过程改善的基准】

19、单选题：
‌敏捷开发是应对快速变化的需求的一种软件开发能力。它以（      ）为核心，采用迭代、循序渐进的方法进行软件开发。‍
选项：
A: 用户的需求进化
B: 代码质量
C: 软件功能
D: 软件容错性
答案: 【 用户的需求进化】

20、单选题：
‌根据IEEE，“软件构造”指的是通过（      ）、验证、单元测试、集成测试和调试的组合，详细地创建可工作的、有意义的软件。‎
选项：
A: 详细设计
B: 总体设计
C: 编码
D: 获取需求
答案: 【 编码】

21、单选题：
下列哪些模型不是迭代模型：（      ）​‌​
选项：
A: Scrum
B: 极限编程
C: 进化式原型法
D: 瀑布模型
答案: 【 瀑布模型】

22、单选题：
‍软件构造的知识域分为5 个子域：软件构造基础，管理构造，实际考虑，（    ），软件构造工具。‏
选项：
A: 需求构造
B: 测试构造
C: 构造技术
D: 构造方法
答案: 【 构造技术】

23、单选题：
‏除了功能的正确性，软件还要满足可靠性、可用性、（      ）、可维护性等质量属性。​
选项：
A: 可理解性
B: 可重用性
C: 可移植性
D: 可测试性
答案: 【 可移植性】

24、单选题：
‌IDE 的特点是（    ）、可视化和自动化。‏
选项：
A: 简介化
B: 集成化
C: 标准化
D: 多功能化
答案: 【 集成化】

25、单选题：
‎命令式语言可以细分为冯·诺依曼式语言、脚本语言和（    ）。‍
选项：
A: 面向对象语言
B: 过程化设计语言
C: 汇编语言
D: 机器语言
答案: 【 面向对象语言】

26、单选题：
‍按照教材的说法 ，敏捷开发创造了一些新的技术或实践，如测试驱动开发等，但不包括（）。‌‍‌
选项：
A: 结对编程
B: 代码重构
C: 持续集成
D: 软件体系结构
答案: 【 软件体系结构】

27、单选题：
​最佳实践中的（）指的是有机体的构造、功能及其相互关系、工作原理，如可视化编程的事件响应、类型的多态。‌
选项：
A: 原则
B: 技术 
C:   机制
D: 方法
答案: 【   机制】

28、单选题：
‏最佳实践中的（）是获得一个客体（对象）的步骤或过程。作为一个系统的步骤、技术活动被特定的专业或艺术采纳，是技能或技术的全部。‎
选项：
A: 原则
B:  机制
C:  技术
D: 方法
答案: 【 方法】

29、单选题：
‌根据软件构造的含义，软件构造就是通过设计、编码、测试等一系列活动创建软件，没有特别指出（）。‏
选项：
A: 有意的
B: 可运行的
C: 可工作的
D: 高质量的
答案: 【 高质量的】

30、单选题：
‍Java程序中main()函数的值是什么?‌
选项：
A: String
B: int
C: char
D: void
答案: 【 void】

31、单选题：
‎在Java语言中，下列数据类型的精度由高到低的顺序是()。‍
选项：
A: float，double，int，long
B: double，float，int，byte
C: byte，long，double，float
D: double，int，float，long
答案: 【 double，float，int，byte】

32、多选题：
​软件=（    ）+（    ）+（    ）。‍
选项：
A: 程序
B: 数据
C: 文档
D: 数据结构
E: 算法
答案: 【 程序;
数据;
文档】

33、多选题：
​软件按其功能划分为三种类型：（        ）‌
选项：
A: 系统软件
B: 应用软件
C: 支撑软件
D: 娱乐软件
E: 实时软件
答案: 【 系统软件;
应用软件;
支撑软件】

34、多选题：
‍软件按其工作方式划分为：（       ）‏
选项：
A: 并行软件
B: 应用软件
C: 实时软件
D: 分时软件
E: 交互式软件
F: 批处理软件
答案: 【 实时软件;
分时软件;
交互式软件;
批处理软件】

35、多选题：
‌软件按服务对象的范围划分为：（    ）‏
选项：
A: 应用软件
B: 民用软件
C: 项目软件
D: 专业软件
E: 产品软件
答案: 【 项目软件;
产品软件】

36、多选题：
一个软件可能包含以下哪些特性：（      ）‎‏‎
选项：
A: 实时特性
B: 快速响应性
C: 分时特性
D: 批处理特性
E: 交互性
答案: 【 实时特性;
分时特性;
批处理特性;
交互性】

37、多选题：
‏从用户的角度，软件生存周期分为下列三个阶段:（      ）‏
选项：
A: 测试软件
B: 用户评价
C: 提出需求
D: 获取软件
E: 使用软件
答案: 【 提出需求;
获取软件;
使用软件】

38、多选题：
​从软件开发者的角度，一般把软件生存周期分为下列三个阶段:（      ）‎
选项：
A: 需求分析
B: 定义软件
C: 总体设计
D: 开发软件
E: 维护软件
答案: 【 定义软件;
开发软件;
维护软件】

39、多选题：
‎软件测试也属于实现阶段的活动，可以分为:（    ）‎
选项：
A: 单元测试
B: 集成测试
C: 系统测试
D: 验收测试
E: 黑盒测试
F: 白盒测试
答案: 【 单元测试;
集成测试;
系统测试;
验收测试】

40、多选题：
‌软件维护分为4种类型：（      ）‏
选项：
A: 改正性维护
B: 适应性维护
C: 完善性维护
D: 预防性维护
E: 可用性维护
答案: 【 改正性维护;
适应性维护;
完善性维护;
预防性维护】

41、多选题：
‍瀑布式开发模型的主要问题：（      ）‎
选项：
A: 阶段划分僵硬，每个阶段不能缺省，而且产生大量文档，增加了工作量。
B: 逐步增加部件的方式，很容易退化为边做边改模型，从而使软件过程的控制失去整体性。
C: 由于各个部件是逐渐并入已有软件的，必须确保每次增加的部件不破坏已构造好的系统，这需要软件具备开放式的体系结构，否则系统将失去稳定的结构。
D: 开发是线性的，只有等到整个过程的末期才能见到开发成果——可运行软件，不利于快速响应变化的需求。
E: 早期的错误要等到开发后期的测试阶段才能发现，可能带来严重的后果，增加了开发的风险。
答案: 【 阶段划分僵硬，每个阶段不能缺省，而且产生大量文档，增加了工作量。;
开发是线性的，只有等到整个过程的末期才能见到开发成果——可运行软件，不利于快速响应变化的需求。;
早期的错误要等到开发后期的测试阶段才能发现，可能带来严重的后果，增加了开发的风险。】

42、多选题：
​增量开发模型的优点:（      ）‎
选项：
A: 在短时间内向用户提交一个可运行软件，能够提供解决用户急用的一些功能。
B: 用户有较充分的时间学习和适应新的产品。
C: 可以使软件适应需求变化。
D: 有利于系统维护,当需求变更时，只变更部分部件，而不必影响整个系统。
E: 可以使软件具有良好的稳定性和完整性。
答案: 【 在短时间内向用户提交一个可运行软件，能够提供解决用户急用的一些功能。;
用户有较充分的时间学习和适应新的产品。;
可以使软件适应需求变化。;
有利于系统维护,当需求变更时，只变更部分部件，而不必影响整个系统。】

43、多选题：
‎敏捷开发4个核心价值观:（    ）‏
选项：
A: 用最快的速度开发以满足客户需求
B: 个体和互动胜过流程和工具
C: 响应变化胜过遵循计划
D: 工作的软件胜过详尽的文档
E: 客户合作胜过合同谈判
答案: 【 个体和互动胜过流程和工具;
响应变化胜过遵循计划;
工作的软件胜过详尽的文档;
客户合作胜过合同谈判】

44、多选题：
‎IDE的特点是（    ）。‏
选项：
A: 集成化
B: 可视化
C: 自动化
D: 多功能化
E: 简洁化
答案: 【 集成化;
可视化;
自动化】

45、多选题：
高级程序语言存在不同的分类。一种划分标准是按照语言的计算模型，将高级语言分为两个大类：（    ）‎
选项：
A: 过程式
B: 面向对象式
C: 声明式
D: 命令式
E: 函数式
答案: 【 声明式;
命令式】

46、多选题：
‍命令式语言可以细分为:（      ）‍
选项：
A: 冯·诺依曼式语言
B: 脚本语言
C: 面向对象语言
D: 过程化语言
E: 机器语言
答案: 【 冯·诺依曼式语言;
脚本语言;
面向对象语言】

47、多选题：
‌软件开发可以理解为是做（）的过程。‍
选项：
A: 决策
B: 协商
C: 权衡
D: 选择
E: 维护
答案: 【 决策;
权衡;
选择】

48、多选题：
‏本书使用的“软件构造”指的是运用软件最佳实践，通过（）迭代过程，增量地建造出可运行软件。​
选项：
A: 分析
B: 设计
C: 编码
D: 调试
E: 测试
答案: 【 设计;
编码;
测试】

49、多选题：
‌‌‌按照教材，敏捷开发创造了一些新的技术或实践，主要包含（）。‌
选项：
A: 面向对象技术
B: 测试驱动开发
C: 结对编程
D: 代码重构
E: 设计模式
答案: 【 面向对象技术;
测试驱动开发;
结对编程;
代码重构】

50、多选题：
‏高级程序语言的一种划分标准是按照语言的计算模型，将高级语言分为声明式式和命令式两个大类，前者进一步划分为（）。​
选项：
A: 函数式语言
B: 面向对象语言
C: 逻辑式语言
D: 领域语言
E: 数据流语言
答案: 【 函数式语言;
逻辑式语言;
数据流语言】

51、多选题：
‍从用户的角度，软件生存周期分为（）三个阶段。‍
选项：
A: 提出需求
B: 定义软件
C: 开发软件
D: 获取软件
E: 使用软件
答案: 【 提出需求;
获取软件;
使用软件】

52、多选题：
‏从软件开发者的角度，一般把软件生存周期分为（）三个阶段。‏
选项：
A: 提出需求
B: 定义软件
C: 开发软件
D: 使用软件
E: 维护软件
答案: 【 定义软件;
开发软件;
维护软件】

53、多选题：
‏按照SWEBOK 3.0指南，软件构造知识域的子域——构造技术，包含了（）等。‌
选项：
A: 按契约设计
B: 防御性编程
C: 设计模式
D: 测试先行编程
答案: 【 按契约设计;
防御性编程;
测试先行编程】

54、多选题：
​软件规模的划分依据有多个因素，通常不包含（）。‍
选项：
A: 参加人数
B:  组织方式
C: 运行平台
D: 研发周期
E: 产品规模
答案: 【  组织方式;
运行平台】

55、判断题：
‏软件是由计算机程序和程序设计的概念发展演化过来的，是程序和程序设计发展到一定规模后并且在逐步商品化的过程中形成的。‏
选项：
A: 正确
B: 错误
答案: 【 正确】

56、判断题：
计算机程序是为了解决广泛问题而用程序设计语言描述的适合计算机处理的语句序列。‏​‏
选项：
A: 正确
B: 错误
答案: 【 错误】

57、判断题：
‏“软件=程序+数据”，其中程序是软件的中枢和骨架。‏
选项：
A: 正确
B: 错误
答案: 【 错误】

58、判断题：
‏软件按其功能划分为三种类型：系统软件、支撑软件和应用软件。‏
选项：
A: 正确
B: 错误
答案: 【 正确】

59、判断题：
‏在计算机技术发展的早期，软件开发的主要活动就是算法研究。‎
选项：
A: 正确
B: 错误
答案: 【 错误】

60、判断题：
‍从软件使用者的角度，把软件生存周期分为定义软件、开发软件和维护软件三个阶段。‏
选项：
A: 正确
B: 错误
答案: 【 错误】

61、判断题：
​软件实现是完成可以运行程序及数据的软件开发过程。‍
选项：
A: 正确
B: 错误
答案: 【 正确】

62、判断题：
‍软件维护分为只有3种类型：改正性维护、适应性维护和完善性维护。‎
选项：
A: 正确
B: 错误
答案: 【 错误】

63、判断题：
‌在软件生存周期中，软件维护会持续很长一段时间，甚至超过全周期的一半。‏
选项：
A: 正确
B: 错误
答案: 【 正确】

64、判断题：
‏瀑布式开发过程，也叫软件生存期模型。它规定自上而下、相互分离的固定次序。‎
选项：
A: 正确
B: 错误
答案: 【 错误】

65、判断题：
‍功能需求定义软件在抽象级别应该提供的基本功能。‌
选项：
A: 正确
B: 错误
答案: 【 正确】

66、判断题：
‎根据软件生存周期的概念和划分，软件测试不属于实现阶段的活动。​
选项：
A: 正确
B: 错误
答案: 【 错误】

67、判断题：
​增量开发模型的基本思想是让开发者能够从早期的开发、系统的增量、交付的版本中学到经验。​
选项：
A: 正确
B: 错误
答案: 【 正确】

68、判断题：
‌敏捷开发是应对较慢速变化的需求的一种软件开发能力。‎
选项：
A: 正确
B: 错误
答案: 【 错误】

69、判断题：
‍敏捷开发遵循软件开发的基本原则，如抽象、模块内聚、模块之间松散耦合、信息隐藏等。‎
选项：
A: 正确
B: 错误
答案: 【 正确】

70、判断题：
​Scrum 是一个用于开发和维持简单软件产品的框架，是一个增量的、迭代的开发过程。‌
选项：
A: 正确
B: 错误
答案: 【 错误】

71、判断题：
‌如何考虑构造，既构造的主要工作是什么，在某种程度上依赖于采用的生存周期模型。‎
选项：
A: 正确
B: 错误
答案: 【 正确】

72、判断题：
‎软件构造是软件开发的中心活动。‌
选项：
A: 正确
B: 错误
答案: 【 正确】

73、判断题：
​理想的软件项目在构造后要进行仔细的需求分析和架构设计。​
选项：
A: 正确
B: 错误
答案: 【 错误】

74、判断题：
‏数据流语言的计算模型是原始函数节点上的信息元素（Tokens）流，它们到达节点后触发节点的计算。‍
选项：
A: 正确
B: 错误
答案: 【 正确】

75、判断题：
‍从软件开发者的角度，一般把软件生存周期分为提出需求、开发软件和维护软件三个阶段。​‍​
选项：
A: 正确
B: 错误
答案: 【 错误】

76、判断题：
‎从软件开发者的角度，一般把软件生存周期分为定义软件、获取软件和维护软件三个阶段。‍
选项：
A: 正确
B: 错误
答案: 【 错误】

77、判断题：
‎从用户的角度，软件生存周期分为定义软件、 获取软件、使用软件三个阶段，‌
选项：
A: 正确
B: 错误
答案: 【 错误】

78、判断题：
​本课程对案例开发过程中的每个需求和问题都提出并分析几个典型的候选设计，然后给出一两个具体的实现。所以，对案例的软件构造也就是几个。‍
选项：
A: 正确
B: 错误
答案: 【 错误】

79、填空题：
‎软件按其功能划分为三种类型：支撑软件、应用软件和________软件。‏
答案: 【 系统】

80、填空题：
‌图灵奖获得者沃斯（Niclaus Wirth）提出的“程序=算法+________”是程序设计的精辟观点。​
答案: 【 数据结构】

81、填空题：
​从用户的角度，软件生存周期分为下列三个阶段：_________、获取软件和使用软件。​
答案: 【 需求】

82、填空题：
‎软件维护分为：改正性维护、适应性维护、完善性维护和__________。​
答案: 【 预防性】

83、填空题：
‎Scrum是一个用于开发和维持复杂软件的框架，是一个增量的、________的开发过程。‎
答案: 【 迭代】

84、填空题：
‌_________开发过程，也叫软件生存期模型。它按照软件生命周期，把开发分为制定计划、需求分析、软件设计、程序编写、软件测试和运行维护等6个基本活动，并且规定了它们自上而下、相互衔接的固定次序。‎
答案: 【 瀑布】

85、填空题：
‏面向对象软件构造（动词）是运用面向对象技术开发具有_________的软件系统。‏
答案: 【 结构】

86、填空题：
‎软件按其工作方式划分为：________软件、分时软件、交互式软件和批处理软件。‎
答案: 【 实时】

87、填空题：
‍在计算机技术发展的早期，软件开发的主要活动就是________。‎
答案: 【 程序设计】

88、填空题：
​软件实现与通常的程序设计的主要区别是软件的集成与________。​
答案: 【 测试】

89、填空题：
‎________维护是为适应环境的变化而进行的软件修改活动。‎
答案: 【 适应性】

90、填空题：
​在瀑布式开发模型中，软件开发的各项活动严格按照________方式进行。‍
答案: 【 线性】

91、填空题：
​迭代周期的长度跟软件的开发________和规模有关系。​
答案: 【 周期】

92、填空题：
‍代码重构指的是改变程序的_______而不改变其行为，以便提高代码的可读性、易修改性等。‌
答案: 【 结构】

93、填空题：
​在所有的软件开发中，________是软件开发的中心活动。‏
答案: 【 构造】

94、填空题：
‍软件运行环境，广义上说，是一个软件运行所要求的各种条件，包括_______环境和硬件环境。‏
答案: 【 软件】

95、填空题：
‌操作系统将计算机的硬件细节屏蔽，将计算机抽象成______资源。‌
答案: 【 虚拟】

96、填空题：
‌图灵奖获得者沃斯（Niclaus Wirth）提出的“程序=__________+数据结构”是程序设计的精辟观点。 ‎
答案: 【 算法】

97、填空题：
‍软件实现与通常的程序设计的主要区别是软件的______与测试。‏‍‏
答案: 【 集成】

98、填空题：
‍根据IEEE计算机学会发布的软件工程知识体系（SWEBOK 3.0）指南，软件工程学科的实践知识域中有______，指的是通过编码、验证、单元测试、集成测试和调试的组合，详细地创建可工作的、有意义的软件。 ‍
答案: 【 软件构造】

99、填空题：
‌高级程序语言的一种划分标准是按照语言的计算模型，将高级语言分为_______式和命令式两个大类，前者进一步划分为函数式语言、逻辑式语言和数据流语言。‎
答案: 【 声明】

100、填空题：
‎软件开发工具的一个发展趋势是使用可视化的______，用图形用户界面用GUI集成了代码编写、静态分析、编译、调试、连接、打包等功能的一体化软件开发套件。‍
答案: 【 IDE##%_YZPRLFH_%##集成开发环境】

101、填空题：
‌软件开发一直缺乏坚实的理论基础，所以软件行业借用了管理学的______的概念来概括到达用户满意的、可以反复使用的软件开发的一切手段，包括技术、方法、过程、活动或机制，可以使生产或管理的结果达到最优，并减少出错的可能性。‌‌‌
答案: 【 最佳实践##%_YZPRLFH_%##Best Practice】

102、填空题：
‌按照语言的转换和执行方式，高级语言分为编译型语言和解释型语言。Java、C#等是不是典型的编译型语言或解释型语言，而是_____型语言，即把程序编译成特定的中间语言，然后由相应的虚拟机作为解释器去执行。‏‌‏
答案: 【 混合】

103、填空题：
‏下列Java语句序列执行后，k 的值是_____。‍  int  i=4,j=5,k=9,m=5; ‍‏   if(i>j||m<k)  k++;  else k–; ‍‏‍
答案: 【 10】

2 模块化软件构造测验

1、单选题：
‎‎‎在软件构造中，分解的核心是（）。‎‎‎
选项：
A: 将问题分解的尽可能小
B: 将分解的若干小问题最终合并
C: 将问题分解的足够简单解决
D: 将多个问题、难点或关注点分离
答案: 【 将多个问题、难点或关注点分离】

2、单选题：
‌（）是面向方面的程序设计的核心概念。​‌​
选项：
A: 关注点分离
B: 确定编程方向
C: 多个问题分离
D: 难点分离
答案: 【 关注点分离】

3、单选题：
‏在软件设计中，（）是把问题分解成容易理解、便于控制、便于实现的子问题的一个重要手段，是实现控制复杂性的方式。‍‏‍
选项：
A: 模块化
B: 结构化
C: 函数化
D: 面向对象
答案: 【 模块化】

4、单选题：
‌在程序系统的结构中，模块是（）的程序单元。‍‌‍
选项：
A: 可组合、可更换
B: 可维护
C: 可测试
D: 可修改、可理解
答案: 【 可组合、可更换】

5、单选题：
‍模块具有三大特征：独立性、（）、通用性。‏‍‏
选项：
A: 可理解性
B: 可维护性
C: 互换性
D: 整洁性
答案: 【 互换性】

6、单选题：
​模块化是现代软件开发技术的一个基本原则。（）是实现软件模块化的一个基本手段。‏​‏
选项：
A: 文件
B: 库
C: 代码组
D: 函数
答案: 【 函数】

7、单选题：
‍在模块设计中，最基本的是算法和（）的设计。‍‍‍
选项：
A: 接口
B: 数据结构
C: 代码结构
D: 功能
答案: 【 数据结构】

8、单选题：
‎图灵奖获得者 Wirth 提出的（）的方法，可以简化为“算法+数据结构=程序”。‌‎‌
选项：
A: 面向对象设计
B: 面向数据流设计
C: 过程化设计
D: 结构化程序设计
答案: 【 结构化程序设计】

9、单选题：
​（）是计算机存储、组织数据的方式，是指相互之间存在一种或多种特定关系的数据元素的集合。‎
选项：
A: 数据结构
B: 算法 
C: 内存
D: 数据库
答案: 【 数据结构】

10、单选题：
‍根据软件的模块化理论，下列四种内聚，由弱到强排序正确的是（）。​‍​
选项：
A: 逻辑内聚 偶然内聚 时间内聚 过程内聚
B: 偶然内聚 逻辑内聚 过程内聚 时间内聚
C: 偶然内聚 逻辑内聚 时间内聚 过程内聚
D: 逻辑内聚 偶然内聚 过程内聚 时间内聚
答案: 【 偶然内聚 逻辑内聚 时间内聚 过程内聚】

11、单选题：
‌根据软件的模块化理论，下列内聚最强的是（）。​
选项：
A: 功能内聚
B: 顺序内聚
C: 通信内聚
D: 过程内聚
答案: 【 功能内聚】

12、单选题：
‍一个函数中各个处理元素都密切相关于同一功能且必须顺序执行，前一功能元素的输出就是下一功能元素的输入，即一个函数完成多个功能，这些函数又必须按序执行是下列哪种内聚（）。​‍​
选项：
A: 时间内聚
B: 过程内聚
C: 通信内聚
D: 顺序内聚
答案: 【 顺序内聚】

13、单选题：
‎根据软件的模块化理论，下列耦合度最低的是（）。‎
选项：
A: 控制耦合
B: 外部耦合
C: 非直接耦合
D: 数据耦合
答案: 【 非直接耦合】

14、单选题：
‎根据模块化理论，下列耦合度最强的是（）。​
选项：
A: 内容耦合
B: 公共耦合
C: 外部耦合
D: 数据耦合
答案: 【 内容耦合】

15、单选题：
‎根据模块化理论，一组函数都访问同一（）而不是同一（），而且不是通过参数传递该全局变量的信息叫做外部耦合。‌‎‌
选项：
A: 全局简单变量 全局数据结构
B: 全局数据结构 全局简单变量
C: 公共数据环境 全局简单变量
D: 全局数据结构 公共数据环境
答案: 【 全局简单变量 全局数据结构】

16、单选题：
‌根据软件的模块化理论，一组函数都访问同一个（）叫做公共耦合。‌
选项：
A: 公共数据环境
B: 全局简单变量
C: 通信区
D: 内存地址
答案: 【 公共数据环境】

17、单选题：
‍根据软件的模块化理论，下列耦合度由强到弱排序正确的是（）。‌
选项：
A: 外部耦合 内部耦合 直接耦合 非直接耦合
B: 内容耦合 外部耦合 控制耦合 非直接耦合
C: 内部耦合 外部耦合 非直接耦合 直接耦合
D: 标记耦合 控制耦合 外部耦合 公共耦合
答案: 【 内容耦合 外部耦合 控制耦合 非直接耦合】

18、单选题：
‏根据软件的模块化理论，一个函数通过传递开关、标志、名字等控制信息，明显地控制和选择另一函数的功能叫做（）。‌‏‌
选项：
A: 标记耦合
B: 控制耦合
C: 外部耦合
D: 内容耦合
答案: 【 控制耦合】

19、单选题：
‌根据软件的模块化理论，若一组函数通过参数表传递记录信息，这样的耦合称为（）。‏
选项：
A: 非直接耦合
B: 控制耦合
C: 标记耦合
D: 外部耦合
答案: 【 标记耦合】

20、单选题：
​一个函数直接修改另一个函数的数据，或直接转入另一个函数，或者一个函数有多个入口叫做（）。​
选项：
A: 非直接耦合
B: 公共耦合
C: 外部耦合
D: 内容耦合
答案: 【 内容耦合】

21、单选题：
‌测试有助于提高程序质量。编写测试可以迫使程序员从不同的角度审视程序，使得程序设计易于调用、可测试、易修改、（）。‌‌‌
选项：
A: 简洁
B: 易读
C: 易维护
D: 易理解
答案: 【 易维护】

22、单选题：
​ISO为程序质量定义了6个独立的质量特性，它们是：①功能性，②可靠性，③（），④效率，⑤，可维护性和⑥可移植性。‎​‎
选项：
A: 可读性
B: 简洁性
C: 可测试性
D: 可用性
答案: 【 可用性】

23、单选题：
​可维护可以细化为5个子特性，它们是（）、易改变性、稳定性、易测试性、维护性的依从性。​
选项：
A: 易分析性
B: 可理解性 
C: 易读性 
D: 标准性
答案: 【 易分析性】

24、单选题：
‏依据编码风格，命名标识符的首要原则是（）。‎
选项：
A: 简单
B: 使用驼峰命名法或匈牙利命名法
C: 要完全准确地表达所代表的事物或动作
D: 正确
答案: 【 要完全准确地表达所代表的事物或动作】

25、单选题：
‌依据编码风格，代码的（）是区别代码好坏的一个关键特性。‍
选项：
A: 缩进
B: 编排
C: 长度
D: 复杂程度
答案: 【 编排】

26、单选题：
​一个结构类型的数据结构是否包含非独立变量，主要考虑下列因素。①获取其值的难易程度。②（）‎​‎
选项：
A: 计算过程复杂
B: 使用它的频繁程度 
C: 是否有副作用 
D: 它是否是原子结构
答案: 【 使用它的频繁程度 】

27、单选题：
​本案例中用数组表示算式的主要优势包括：节省存储空间、（）等。‌
选项：
A: 易读
B: 有计算机语言的含义 
C: 可以表示复杂的算式
D: 提高程序效率
答案: 【 可以表示复杂的算式】

28、单选题：
​如果用数组存不同的算式作为“习题”，产生60道不同算式的习题时,算式总共最少比较的次数是（）。‍
选项：
A: 60
B: 120
C: 1200
D: 1770
答案: 【 1770】

29、单选题：
​如果用数组存不同的算式作为“习题”，产生80道不同算式的习题时，算式总共最少比较的次数是（）。‌
选项：
A: 800
B: 2400
C: 3160
D: 3200
答案: 【 3160】

30、单选题：
​对本案例，假设算式有3种数据结构：结构体、一维数组和字符串；习题有4种,则案例程序可以有（）种数据结构的组合方式。​​​
选项：
A: 3
B: 4
C: 7
D: 12
答案: 【 12】

31、单选题：
‌在软件测试中，测试用例是一组输入、（）和通过/失败准则。‌
选项：
A: 测试数据
B: 运行条件
C: 运行结果
D: 测试步骤
答案: 【 运行条件】

32、单选题：
‌测试需求要求程序的预期结果和实际运行结果都要明确、合理、（）并可比较。‌
选项：
A: 正确
B: 精确
C: 可观察
D: 可记录
答案: 【 可观察】

33、单选题：
​由于不能穷尽测试程序，我们希望遵循软件测试的（）原则，即用尽量少的测试、最小的消耗能最大程度地保证程序的正确性，使程序满足需求。‌​‌
选项：
A: 合理性
B: 经济性
C: 足够的
D: 覆盖性
答案: 【 经济性】

34、单选题：
‍基于边界值分析设计测试用例，若输入条件指定为以a和b为边界的范围，则测试数据应该包括a、b，略大于a和（）的值作为合法的测试数据。‏
选项：
A: 略小于a
B: 略小于b
C: 略大于b
D: 中间
答案: 【 略小于b】

35、单选题：
‎在程序设计和软件开发的实践和理论中，存在过以（）为中心和以操作为中心的开发方法。 ‏‎‏
选项：
A: 数据
B: 文件
C: 组织
D: 构架
答案: 【 数据】

36、单选题：
‌根据模块化理论，理想的内聚性要求模块的功能应明确、（）。‎
选项：
A: 高级
B: 清晰
C: 单一
D: 全面
答案: 【 单一】

37、单选题：
‏根据模块化理论，()是两函数之间没有直接关系，之间的联系完全是通过其他函数的控制和调用来实现的。‌‏‌
选项：
A: 非直接耦合
B: 控制耦合
C: 标记耦合
D: 外部耦合
答案: 【 非直接耦合】

38、单选题：
​通过信息()可以减少应用程序对硬件、操作系统的依赖关系。‌
选项：
A: 外显
B: 模块化
C: 隐蔽
D: 依赖
答案: 【 隐蔽】

39、单选题：
​int add (int m,int n) {​​    if (m > 100 || m < 0 || n > 100 || n < 0)​​        return -1;​​    return m+n;​​}​​​​该程序期望输出两个100以内的自然数之和，和可以超过100。返回-1则表示输入参数不符合要求，不是期望的结果。​​这个程序有两个输入参数。测试该程序的一个策略是，让其中的一个参数的值保持不变（比如让n=10），采用等价类与边界值分析专注测试参数m；然后再让m的值不变、专注测试n对程序的影响。​​假设取n=10，用等价类与边界值分析方法测试程序的期望结果和不期望结果，把m的值按照1~9，10~19、…，90~99划分成有效等价区间，最经济的测试数据是多少个？​
选项：
A: 10
B: 11
C: 12
D: 13
答案: 【 12】

40、单选题：
‎对案例问题代码2.1可以分解成4个部分。​‎（1）增加一个程序头打印函数void printHeader()，比如简单说明本程序的作用和使用。​‎（2）函数void generateEquations()，产生加法或减法算式的符号串并存入一个数组。​‎（3）输出习题的函数void printExercise()，它接收generateEquations的输出，按照要求打印输出所有的算式。​‎（4）输出习题中每个算式的计算结果void printCalculations()。​‎程序的实现方式有很多，下面的代码给出了主程序及部分模块代码。它定义了两个非局部变量，分别是存放算式符号串的数组和每个算式计算结果的数组。​‎public class BinaryOperation_01 {​// 存放算术符号串的数组，非局部变量​‎    static String [] exercises = new String[50];​// 存放算术题结果的数组，非局部变量  ​‎    static short [] results = new short[50];      ​‎    public static void printHeader(){…… }​‎    public static void generateEquations(){​‎            ……​‎            exercises[i]=""+m+o+n+"=";​‎            results[i]=v;​‎        }​‎    }​‎    public static void printExercise(){​‎        for (int i=0;i< exercises.length; i++){​‎            System.out.println(""+(i+1)+":t"+e[i]);​‎        }​‎    }​‎    public static void printCalculations(){​‎        for (int i=0;i< results.length; i++){​‎            System.out.println(""+(i+1)+":t"+r[i]);​‎        }​‎    }​‎    public static void main(String[] args) {​‎        printHeader();​‎        generateEquations();​‎        printExercise();​‎        printCalculations();   ​‎    }​‎}​‎从模块化设计理论分析，函数printExercise和generateEquations出现在主程序中的耦合性，属于（）。​
选项：
A: 非直接耦合
B: 数据耦合
C: 标记耦合
D: 公共耦合
答案: 【 公共耦合】

41、单选题：
对案例问题代码2.1可以分解成4个部分。​（1）增加一个程序头打印函数void printHeader()，比如简单说明本程序的作用和使用。​（2）函数void generateEquations()，产生加法或减法算式的符号串并存入一个数组。​（3）输出习题的函数void printExercise()，它接收generateEquations的输出，按照要求打印输出所有的算式。​（4）输出习题中每个算式的计算结果void printCalculations()。​程序的实现方式有很多，下面的代码给出了主程序及部分模块代码。它定义了两个非局部变量，分别是存放算式符号串的数组和每个算式计算结果的数组。​public class BinaryOperation_01 {​// 存放算术符号串的数组，非局部变量​    static String [] exercises = new String[50];​// 存放算术题结果的数组，非局部变量  ​    static short [] results = new short[50];      ​    public static void printHeader(){…… }​    public static void generateEquations(){​            ……​            exercises[i]=""+m+o+n+"=";​            results[i]=v;​        }​    }​    public static void printExercise(){​        for (int i=0;i< exercises.length; i++){​            System.out.println(""+(i+1)+":t"+e[i]);​        }​    }​    public static void printCalculations(){​        for (int i=0;i< results.length; i++){​            System.out.println(""+(i+1)+":t"+r[i]);​        }​    }​    public static void main(String[] args) {​        printHeader();​        generateEquations();​        printExercise();​        printCalculations();   ​    }​}​从模块化设计理论分析，如果函数printExercise()修改为接收一个字符串数组，即printExercise(String[]),那么它和generateEquations()出现在主程序中的耦合性，属于（）。​
选项：
A: 非直接耦合
B: 数据耦合
C: 标记耦合
D:  公共耦合
答案: 【 标记耦合】

42、单选题：
对案例问题代码2.1可以分解成4个部分。‌（1）增加一个程序头打印函数void printHeader()，比如简单说明本程序的作用和使用。‌（2）函数void generateEquations()，产生加法或减法算式的符号串并存入一个数组。‌（3）输出习题的函数void printExercise()，它接收generateEquations的输出，按照要求打印输出所有的算式。‌（4）输出习题中每个算式的计算结果void printCalculations()。‌程序的实现方式有很多，下面的代码给出了主程序及部分模块代码。它定义了两个非局部变量，分别是存放算式符号串的数组和每个算式计算结果的数组。‌public class BinaryOperation_01 {‌// 存放算术符号串的数组，非局部变量‌    static String [] exercises = new String[50];‌// 存放算术题结果的数组，非局部变量  ‌    static short [] results = new short[50];      ‌    public static void printHeader(){…… }‌    public static void generateEquations(){‌            ……‌            exercises[i]=""+m+o+n+"=";‌            results[i]=v;‌        }‌    }‌    public static void printExercise(){‌        for (int i=0;i< exercises.length; i++){‌            System.out.println(""+(i+1)+":t"+e[i]);‌        }‌    }‌    public static void printCalculations(){‌        for (int i=0;i< results.length; i++){‌            System.out.println(""+(i+1)+":t"+r[i]);‌        }‌    }‌    public static void main(String[] args) {‌        printHeader();‌        generateEquations();‌        printExercise();‌        printCalculations();   ‌    }‌}‌从模块化设计理论分析，函数printHeader()和generateEquations()出现在主程序中的耦合性，属于（）。‌​‌
选项：
A: 非直接耦合
B: 数据耦合
C: 标记耦合
D: 控制耦合
答案: 【 非直接耦合】

43、单选题：
对案例问题代码2.1可以分解成4个部分。‏（1）增加一个程序头打印函数void printHeader()，比如简单说明本程序的作用和使用。‏（2）函数void generateEquations()，产生加法或减法算式的符号串并存入一个数组。‏（3）输出习题的函数void printExercise()，它接收generateEquations的输出，按照要求打印输出所有的算式。‏（4）输出习题中每个算式的计算结果void printCalculations()。‏程序的实现方式有很多，下面的代码给出了主程序及部分模块代码。它定义了两个非局部变量，分别是存放算式符号串的数组和每个算式计算结果的数组。‏public class BinaryOperation_01 {‏// 存放算术符号串的数组，非局部变量‏    static String [] exercises = new String[50];‏// 存放算术题结果的数组，非局部变量  ‏    static short [] results = new short[50];      ‏    public static void printHeader(){…… }‏    public static void generateEquations(){‏            ……‏            exercises[i]=""+m+o+n+"=";‏            results[i]=v;‏        }‏    }‏    public static void printExercise(){‏        for (int i=0;i< exercises.length; i++){‏            System.out.println(""+(i+1)+":t"+e[i]);‏        }‏    }‏    public static void printCalculations(){‏        for (int i=0;i< results.length; i++){‏            System.out.println(""+(i+1)+":t"+r[i]);‏        }‏    }‏    public static void main(String[] args) {‏        printHeader();‏        generateEquations();‏        printExercise();‏        printCalculations();   ‏    }‏}‏​从模块化设计理论分析，主程序包含函数printExercise()和printCalculations()以便分别输出习题及其结果，主程序作为模块具有的内聚性属于（）。‏
选项：
A: 偶然内聚
B:  过程内聚
C: 通信内聚
D: 顺序内聚
答案: 【 通信内聚】

44、单选题：
​import java.util.Random;‌​public class BinaryOperation_02 {     ‌​    public static void main(String[] args) {‌​        short m=0, n=0,v=0, ov=0;          ‌​        char o=’+’;    ‌​        Random random = new Random();‌​        for (int i=0;i<50; i++){‌​            ov = (short) random.nextInt(2);       // 随机产生运算符‌​            m = (short)random.nextInt(101);       // 随机产生运算数‌​            if (ov == 1){‌​                do {‌​                   n = (short)random.nextInt(101);‌​                   v = (short) (m + n);‌​                } while (100 < v || v < 0);           ‌​                o = ‘+’;‌​            } else {‌​                                   do {‌​                   n = (short)random.nextInt(101);‌​                   v = (short) (m – n);‌​                } while (100 < v || v < 0);‌​                o = ‘-‘;‌​            }           ‌​            System.out.println(""+(i+1)+":t"+m+o+n+"=");‌​        }‌​    }‌​}‌​关于语句“do {…} while (100 < v || v < 0);”，正确的说法是（）。‌
选项：
A: 循环的次数都是固定值。
B: 循环的次数都不能确定。
C: 循环的次数是在0到100的范围。
D: 上述说法都不正确。
答案: 【 循环的次数都不能确定。】

45、单选题：
‎Java程序中，关于static不正确的说法是（）。​
选项：
A: static可以用来修饰类的成员方法
B: static不可以用来修饰类的成员变量
C: static不可以用来修饰局部变量
D: static关键字允许在没有创建对象的情况下来进行调用（方法/变量）
答案: 【 static不可以用来修饰类的成员变量】

46、单选题：
‍public class StaticTester extends Base{‎‍    static{‎‍        System.out.println("test static");‎‍    }‎‍    public StaticTester(){‎‍       System.out.println("test constructor");‎‍    }‎‍    public static void main(String[] args) {‎‍       new StaticTester();‎‍    }‎‍}‎‍class Base{‎‍    static{‎‍       System.out.println("base static");‎‍   }‎‍   public Base(){‎‍       System.out.println("base constructor");‎‍   }‎‍}‎‍运行这个Java程序后，输出结果是（）。‎
选项：
A: base staticbase constructortest statictest constructor
B: test static test constructorbase staticbase constructor
C: base statictest staticbase constructortest constructor
D: test staticbase statictest constructorbase constructor
答案: 【 base statictest staticbase constructortest constructor】

47、单选题：
‌Java程序中main()函数的值是什么?‎
选项：
A: String
B: int
C: char
D: void
答案: 【 void】

48、单选题：
‎下列Java方法定义中，正确的是( )。​
选项：
A: int x( int a,b ) { return (a-b); }
B:  double x( int a,int b) { int w; w=a-b; }
C: double  x( a,b ) { return  b;  }
D: int  x( int a,int b) {  return  a-b;  }
答案: 【 int  x( int a,int b) {  return  a-b;  }】

49、单选题：
‏下列Java方法定义中，正确的是( )。‍​
选项：
A: void x ( int a,int b ); { return (a-b); }
B: x ( int a,int b) { return a-b; }
C: double x {  return  b;  }
D: int x ( int a,int b) { return a+b; }
答案: 【 int x ( int a,int b) { return a+b; }】

50、多选题：
‌模块化是把问题分解成（）的子问题的一个重要手段，是实现控制复杂性的方式。​
选项：
A: 容易理解
B: 便于控制
C: 便于实现
D: 便于测试
E: 足够小
答案: 【 容易理解;
便于控制;
便于实现】

51、多选题：
‍在程序系统的结构中，模块是（）的程序单元。‌
选项：
A: 可组合
B: 可更换
C: 可维护
D: 可测试
E: 可修改
答案: 【 可组合;
可更换】

52、多选题：
‏根据模块化理论，模块具有三大特征，包括（）。‎‏‎
选项：
A: 独立性
B: 可理解性
C: 互换性
D: 可移植性
E: 通用性
答案: 【 独立性;
互换性;
通用性】

53、多选题：
‍在模块设计中，最基本的是（）和（）的设计。‎
选项：
A: 接口
B: 算法
C: 代码结构
D: 数据结构
E: 功能
答案: 【 算法;
数据结构】

54、多选题：
‌在程序设计和软件开发的实践和理论中，存在过以（）为中心和以（）为中心的开发方法。‌
选项：
A: 算法
B: 功能
C: 数据
D: 效率
E: 操作
答案: 【 数据;
操作】

55、多选题：
‎Meyer提出了下列哪几条标准来评价一种设计方法是否定义了有效的模块系统的能力。‎
选项：
A: 模块可分解性
B: 模块可组装性
C: 模块可理解性
D: 模块连续性
E: 模块保护性
答案: 【 模块可分解性;
模块可组装性;
模块可理解性;
模块连续性;
模块保护性】

56、多选题：
‍模块的独立程度可以由两个定性标准来度量——（）。‍‍‍
选项：
A: 功能个数
B: 接口个数
C: 内聚
D: 耦合
E: 复杂性
答案: 【 内聚;
耦合】

57、多选题：
‏根据模块化理论，下列属于7种内聚的是（）。‎‏‎
选项：
A: 偶然内聚
B: 逻辑内聚
C: 物理内聚
D: 过程内聚
E: 数据内聚
答案: 【 偶然内聚;
逻辑内聚;
过程内聚】

58、多选题：
​根据模块化理论，下列内聚由强到弱排序正确的是（）。‌​‌
选项：
A: 功能内聚 顺序内聚 时间内聚
B: 通信内聚 过程内聚 时间内聚
C: 顺序内聚 过程内聚 逻辑内聚
D: 功能内聚 时间内聚 偶然内聚
E: 过程内聚 时间内聚 顺序内聚
答案: 【 功能内聚 顺序内聚 时间内聚;
通信内聚 过程内聚 时间内聚;
顺序内聚 过程内聚 逻辑内聚;
功能内聚 时间内聚 偶然内聚】

59、多选题：
‏根据模块化理论，下列属于划分的七级耦合的是（）。​
选项：
A: 直接耦合
B: 非直接耦合
C: 内部耦合
D: 外部耦合
E: 内容耦合
答案: 【 非直接耦合;
外部耦合;
内容耦合】

60、多选题：
‌根据模块化理论，下列按照耦合度从低到高排序正确的是（）。‎‌‎
选项：
A: 数据耦合 标记耦合 公共耦合 内容耦合
B: 非直接耦合 控制耦合 外部耦合 内容耦合
C: 外部耦合 控制耦合 内容耦合 公共耦合
D: 内容耦合 公共耦合 外部耦合 非直接耦合
E: 标记耦合 控制耦合 内容耦合 公共耦合
答案: 【 数据耦合 标记耦合 公共耦合 内容耦合;
非直接耦合 控制耦合 外部耦合 内容耦合】

61、多选题：
​ISO为程序质量定义了下列哪几个独立的质量特性（）。‎​‎
选项：
A: 功能性 
B: 可靠性
C: 可用性
D: 效率
E: 可维护性
答案: 【 功能性 ;
可靠性;
可用性;
效率;
可维护性】

62、多选题：
‌根据软件质量，软件的可维护可以细化为那些子特性（）。‌
选项：
A: 易分析性
B: 易改变性
C: 稳定性
D: 易测试性
E: 维护性的依从性
答案: 【 易分析性;
易改变性;
稳定性;
易测试性;
维护性的依从性】

63、多选题：
​软件质量是许多质量属性的综合体现，各种质量属性反映了软件质量的不同方面。从认识和评估的角度，软件质量分为（）。​​​
选项：
A: 外部质量属性
B: 内部质量属性
C: 代码质量属性
D: 功能质量属性
E: 用户体验质量属性
答案: 【 外部质量属性;
内部质量属性】

64、多选题：
‏内部质量属性是在软件设计和编码过程中，通过对中间产品的分析得来的。程序员更关心内部质量，这些属性包括（）。‎‏‎
选项：
A: 可测试性
B: 可扩展性
C: 可维护性
D: 可移植性
E: 可复用性
答案: 【 可测试性;
可扩展性;
可维护性;
可移植性;
可复用性】

65、多选题：
int add (int m,int n) {​    if (m > 100 || m < 0 || n > 100 || n < 0)​        return -1;​    return m+n;​}​该程序期望输出两个100以内的正整数之和，和可以超过100。返回-1则表示输入参数不符合要求​‏用边界值分析的方法测试该程序，如果要测试期望的结果，要选择哪些测试数据（）。​
选项：
A: （1,1）
B: （1,90）
C: （90,1）
D: （99,99）
E: （1,100）
答案: 【 （1,1）;
（99,99）;
（1,100）】

66、多选题：
‎int add (int m,int n) {‎    if (m > 100 || m < 0 || n > 100 || n < 0)‎        return -1;‎    return m+n;‎}‎该程序期望输出两个100以内的正整数之和，和可以超过100。返回-1则表示输入参数不符合要求‎‎用边界值分析的方法测试该程序，如果要测试不期望的结果（输入参数不符合要求），要选择哪些测试数据（）。‎
选项：
A: （1,1）
B:  （0,90）
C: （90,0）
D: （99,99)
E: （1,100）
答案: 【  （0,90）;
（90,0）;
（1,100）】

67、多选题：
‍把“算式”设计成一个具有数据结构的量时，我们有几种选择，每种设计都有一些优势和劣势，比如用数组表示一个“算式”时，具有如下优势。‏‍‏
选项：
A: 节省存储空间
B: 代码可读性高     
C: 直接显示输出
D: 易编程实现
E: 较易修改
答案: 【 节省存储空间;
易编程实现;
较易修改】

68、多选题：
‍把“算式”设计成一个具有数据结构的量时，我们有几种选择，每种设计都有一些优势和劣势，比如C的结构体或类表示一个“算式”时，具有如下优势。​‍​
选项：
A: 节省存储空间
B: 代码可读性高
C: 直接显示输出
D: 易编程实现
E: 较易修改
答案: 【 节省存储空间;
代码可读性高;
易编程实现;
较易修改】

69、多选题：
‌在Java中，语句random.nextInt(5)可能产生的数值有（）。‏
选项：
A: 1
B: 2
C: 3
D: 4
E: 5
答案: 【 1;
2;
3;
4】

70、多选题：
‎import java.util.Random;‏‎public class BinaryOperation_02 {     ‏‎    public static void main(String[] args) {‏‎        short m=0, n=0,v=0, ov=0;          ‏‎        char o=’+’;    ‏‎        Random random = new Random();‏‎        for (int i=0;i<50; i++){‏‎            ov = (short) random.nextInt(2);       // 随机产生运算符‏‎            m = (short)random.nextInt(101);       // 随机产生运算数‏‎            if (ov == 1){‏‎                do {‏‎                   n = (short)random.nextInt(101);‏‎                   v = (short) (m + n);‏‎                } while (100 < v || v < 0);           ‏‎                o = ‘+’;‏‎            } else {‏‎                                   do {‏‎                   n = (short)random.nextInt(101);‏‎                   v = (short) (m – n);‏‎                } while (100 < v || v < 0);‏‎                o = ‘-‘;‏‎            }           ‏‎            System.out.println(""+(i+1)+":t"+m+o+n+"=");‏‎        }‏‎    }‏‎}‏‎程序运行，语句“System.out.println(""+(i+1)+":t"+m+o+n+"=");”可能输出（）。‏
选项：
A: 32: 10+40=  
B: 21: 86-15=  
C: 51: 41+52=  
D: 13+31= 
E: 50: 100+0=  
答案: 【 32: 10+40=  ;
21: 86-15=  ;
50: 100+0=  】

71、多选题：
import java.util.Random;‏public class BinaryOperation_02 {     ‏    public static void main(String[] args) {‏        short m=0, n=0,v=0, ov=0;          ‏        char o=’+’;    ‏        Random random = new Random();‏        for (int i=0;i<50; i++){‏            ov = (short) random.nextInt(2);       // 随机产生运算符‏            m = (short)random.nextInt(101);       // 随机产生运算数‏            if (ov == 1){‏                do {‏                   n = (short)random.nextInt(101);‏                   v = (short) (m + n);‏                } while (100 < v || v < 0);           ‏                o = ‘+’;‏            } else {‏                                   do {‏                   n = (short)random.nextInt(101);‏                   v = (short) (m – n);‏                } while (100 < v || v < 0);‏                o = ‘-‘;‏            }           ‏            System.out.println(""+(i+1)+":t"+m+o+n+"=");‏        }‏    }‏}‏运行程序，语句“do {…} while (100 < v || v < 0);”循环的次数可能是（）。‏
选项：
A: 0
B: 1
C: 11
D: 21
E: 59
答案: 【 1;
11;
21;
59】

72、多选题：
‍import java.util.Random;‌‍public class ExerciseGenerator_t1_1 { ‌‍    public static void generateExerciseOfAdditionEquations (){‌‍        int m,n,v;‌‍        for(int i=0;i<50;i++){‌‍            n=generateOperand();‌‍            do{‌‍                m=generateOperand();‌‍                v=m+n;‌‍            }while (v >= 100);‌‍            System.out.println((i+1)+ ": "+n+" + "+m+" = "+v);  ‌‍        }‌‍    }‌‍    public static int generateOperand(){‌‍        Random random = new Random();‌‍        return (short)random.nextInt(101);‌‍    }‌‍    public static void printHeader(){‌‍        System.out.println("————————————");‌‍        System.out.println("- 程序输出50道100以内的加法运算的口算题 -");‌‍        System.out.println("————————————");‌‍    }‌‍    public static void main(String[] args) {‌‍        printHeader();‌‍        generateExerciseOfAdditionEquations();‌‍    }‌‍}‌‍运行这个Java程序，可能的输出有（）。‌
选项：
A: 20: 0 + 29 = 29
B: 13: 99 + 1 = 100
C: 45: 6 + 93 = 99
D: 50: 99 + 0 = 99
答案: 【 20: 0 + 29 = 29;
45: 6 + 93 = 99;
50: 99 + 0 = 99】

73、多选题：
import java.util.Random;‌public class ExerciseGenerator_t1_1 { ‌    public static void generateExerciseOfAdditionEquations (){‌        int m,n,v;‌        for(int i=0;i<50;i++){‌            n=generateOperand();‌            do{‌                m=generateOperand();‌                v=m+n;‌            }while (v >= 100);‌            System.out.println((i+1)+ ": "+n+" + "+m+" = "+v);  ‌        }‌    }‌    public static int generateOperand(){‌        Random random = new Random();‌        return (short)random.nextInt(101);‌    }‌    public static void printHeader(){‌        System.out.println("————————————");‌        System.out.println("- 程序输出50道100以内的加法运算的口算题 -");‌        System.out.println("————————————");‌    }‌    public static void main(String[] args) {‌        printHeader();‌        generateExerciseOfAdditionEquations();‌    }‌}‌运行这个Java程序，函数int generateOperand()返回的数值可能是（）。‌‌‌
选项：
A: 0
B: 1
C: 19
D: 99
E: 100
答案: 【 0;
1;
19;
99;
100】

74、判断题：
‍​‍程序2.1或2.2明确清晰地定义了的“算式”、“习题”的含义。​‍​
选项：
A: 正确
B: 错误
答案: 【 错误】

75、判断题：
​‍​单纯的阅读程序代码无法确定程序是否正确。‍​‍
选项：
A: 正确
B: 错误
答案: 【 正确】

76、判断题：
‎‍‎面对一个较大问题不能或不知如何直接解决的时候，人们通常采用分而治之的策略。‍‎‍‎‍
选项：
A: 正确
B: 错误
答案: 【 正确】

77、判断题：
‌‌‌依据软件构造技术，关注点聚合是面向方面的程序设计的核心概念。‌‌‌‌‌
选项：
A: 正确
B: 错误
答案: 【 错误】

78、判断题：
‏‍‏模块化是把问题分解成容易理解、便于控制、便于实现的子问题的一个重要手段，是实现控制复杂性的方式。‍‏‍‏‍
选项：
A: 正确
B: 错误
答案: 【 正确】

79、判断题：
‌‌‌‌‌软件模块是指具有相对不独立性的、由数据说明、执行语句等程序对象构成的代码集合。‌
选项：
A: 正确
B: 错误
答案: 【 错误】

80、判断题：
‌​‌函数是实现软件模块化的一个基本手段。​‌​
选项：
A: 正确
B: 错误
答案: 【 正确】

81、判断题：
‍‏‍计算机算法与数据结构密切相关，但一种数据结构不可对应多种算法。‏‍‏
选项：
A: 正确
B: 错误
答案: 【 错误】

82、判断题：
‍‎‍‎对于一个实际应用问题，需要采用模块化技术，分解大的数据、分解大的操作，使用若干数据结构、若干算法来完成整个程序的功能。‎‍‎
选项：
A: 正确
B: 错误
答案: 【 正确】

83、判断题：
‌‏‌Meyer提出了4条标准来评价一种设计方法是否定义了有效的模块系统的能力。‏‌‏
选项：
A: 正确
B: 错误
答案: 【 错误】

84、判断题：
‍在模块化理论中，内聚性是对一个模块内部各个组成元素之间相互结合的紧密程度的度量指标。‎
选项：
A: 正确
B: 错误
答案: 【 正确】

85、判断题：
‌‏‌在模块化理论中，通信内聚指一个函数中各个处理元素都密切相关于同一功能且必须顺序执行。‏‌‏
选项：
A: 正确
B: 错误
答案: 【 错误】

86、判断题：
​‏​在结构化程序设计中，函数之间的调用关系是反映模块耦合性的最重要因素。‏​‏
选项：
A: 正确
B: 错误
答案: 【 正确】

87、判断题：
‏​‏根据模块化理论，公共耦合是一组函数都访问同一个公共数据环境。​‏​
选项：
A: 正确
B: 错误
答案: 【 正确】

88、判断题：
‏‍‏用户需求是从软件使用者的角度描述的对软件的要求。‍‏‍
选项：
A: 正确
B: 错误
答案: 【 正确】

89、判断题：
‏‏‏根据IEEE标准的定义，测试用例是多组输入、运行条件和通过/失败准则。‏‏‏
选项：
A: 正确
B: 错误
答案: 【 错误】

90、判断题：
‍‍‍调试的基本活动包括隔离、定位和更正错误。‍‍‍
选项：
A: 正确
B: 错误
答案: 【 正确】

91、判断题：
‏‌‏软件质量是许多质量属性的综合体现，各种质量属性反映了软件质量的不同方面。‌‏‌
选项：
A: 正确
B: 错误
答案: 【 正确】

92、判断题：
​​​按限制规则划分，若处理每个合法输入的方式都不同，则为每个合法输入生成一个等价类。​​​
选项：
A: 正确
B: 错误
答案: 【 错误】

93、判断题：
‎‏‎根据编码风格，命名标识符的首要原则是要完全准确地表达所代表的事物或动作。‏‎‏
选项：
A: 正确
B: 错误
答案: 【 正确】

94、判断题：
‌等价类划分有两种不同的情况：有效等价类和无效等价类。‍
选项：
A: 正确
B: 错误
答案: 【 正确】

95、判断题：
‌通过分解，人们把一个大的、错综复杂的问题划分成一个相对简单、独立的问题，运用合适的方法分别解决。‌‌‌
选项：
A: 正确
B: 错误
答案: 【