2020 数软-软件构造(青岛大学) 最新满分章节测试答案

本答案对应课程为:点我自动跳转查看
本课程起止时间为:2020-02-17到2020-06-14
本篇答案更新状态:已完结

第 1 章 软件开发概述 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;
集成开发环境】

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

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

103、 问题:下列Java语句序列执行后，k 的值是_____。 int i=4,j=5,k=9,m=5; if(i>j||m10】

【作业】第 2 章 模块化软件构造 域外构造实践作业

1、 问题:构造任务：生成50道100以内加法/减法算式的习题，并输出。（1）每个算式还需要答案；（2）加法算式的和不能超过100；（3）减法算式的差不能小于0；（4）每行整齐地多显示几个算式，不必频繁地下拉屏幕看算式。构造任务2：生成50道100以内加减法算式的混合习题，题中不能有相同的算式。
评分规则: 【 任务 满分任务构造1：70任务构造2：30没有语法错误、通过编译：40%；每个任务或功能，2个测试抓屏：30%编码风格方面：20%提交材料易安装评测：5%实验报告清楚、易阅读：5%
】

第 2 章 模块化软件构造 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:错误
答案: 【错误】

96、 问题:在程序设计中，如果每次分解得到的更小的问题，就可以运用递归方法（函数）来解决原问题。
选项：
A:正确
B:错误
答案: 【错误】

97、 问题:提高软件的模块化能够提高软件的可修改性。
选项：
A:正确
B:错误
答案: 【正确】

98、 问题: 模块化使软件容易测试和调试，其中一个原因是程序的错误通常局限在有关的模块及它们之间的接口。
选项：
A:正确
B:错误
答案: 【正确】

99、 问题:结构化程序设计方法具有“自顶向下”、“逐步求精”、从具体到抽象的特点。
选项：
A:正确
B:错误
答案: 【错误】

100、 问题:描述算法的方式可以采用自然语言或程序设计语言，但是不可以混合使用这两种语言。
选项：
A:正确
B:错误
答案: 【错误】

101、 问题:在程序设计中，数据结构的选择是一个举足轻重的设计考虑因素。
选项：
A:正确
B:错误
答案: 【正确】

102、 问题:在软件构造中，优秀的数据结构决定了软件系统实现的困难程度和系统构造的质量。
选项：
A:正确
B:错误
答案: 【错误】

103、 问题:关于案例设计，总体考虑，把算式用具有3个成员的数组表示是目前算式的最佳数据结构。
选项：
A:正确
B:错误
答案: 【错误】

104、 问题:分析案例的要求，运算数的产生与其约束条件关系密切、不可分离。
选项：
A:正确
B:错误
答案: 【错误】

105、 问题:根据案例，包含算式的习题只能选择数组这个数据结构。
选项：
A:正确
B:错误
答案: 【错误】

106、 问题:案例数据结构的设计，用结构体表示算式的主要优势是直接显示了人易读的形式，而且明确表示出算式组成的数据类型。
选项：
A:正确
B:错误
答案: 【错误】

107、 问题:用符号串表示算式的主要劣势是符号串内的符号没有计算机语言的含义（数据类型），需要解析。
选项：
A:正确
B:错误
答案: 【正确】

108、 问题:软件测试是使用人工或自动手段来运行或测定某个系统的过程，目的在于检测它是否满足规定的需求或者是否弄清预期结果与实际结果之间的差别。
选项：
A:正确
B:错误
答案: 【正确】

109、 问题:软件测试是说明程序是否正确的唯一技术手段。
选项：
A:正确
B:错误
答案: 【错误】

110、 问题:由于测试数据或预期结果的错误而导致根据测试程序显示待测程序可能有误，称为测试漏判。
选项：
A:正确
B:错误
答案: 【错误】

111、 问题:如果待测程序有错，而测试程序没有发现错误，称为测试误判。
选项：
A:正确
B:错误
答案: 【错误】

112、 问题:如果测试失败了，则说明待测程序一定存在错误。
选项：
A:正确
B:错误
答案: 【错误】

113、 问题:根据软件测试理论，满足了一个测试覆盖就能为软件的正确程度提供充足的保证。
选项：
A:正确
B:错误
答案: 【错误】

114、 问题:基于等价类划分测试的基本思想是：将程序可能的输入数据依据某个准则分成若干等价子集，其和覆盖了整个程序即可。
选项：
A:正确
B:错误
答案: 【错误】

115、 问题:Java语言的类的名称不能以小写字母开头。
选项：
A:正确
B:错误
答案: 【错误】

116、 问题:Java程序中，import能导入包及其所包含的类。
选项：
A:正确
B:错误
答案: 【错误】

117、 问题: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:错误
答案: 【正确】

118、 问题:__是把问题分解成容易理解、便于控制、便于实现的子问题的一个重要手段，是实现控制复杂性的方式，软件中的基本手段有函数、类、服务等。
答案: 【模块化】

119、 问题:软件______是指具有相对独立的、由数据说明、执行语句等程序对象构成的代码集合。
答案: 【模块】

120、 问题:__是计算机存储、组织数据的方式，是指相互之间存在一种或多种特定关系的数据元素的集合。
答案: 【数据结构】

121、 问题:根据模块的内聚性定义，__内聚把几种相关的功能或数据组合在一起，每次被调用时，由传送函数参数来确定该函数应完成哪种功能。
答案: 【逻辑】

122、 问题:根据模块的耦合性定义，_耦合是两函数之间没有直接关系，之间的联系完全是通过其他函数的控制和调用来实现的。
答案: 【非直接】

123、 问题:在模块化理论中，模块的内聚性和__是两个相互对立且又密切相关的概念。
答案: 【耦合性】

124、 问题:在程序设计中，如果每次分解得到的更小的问题结构及其解答方式相似，就可以用__（函数）来解决问题。
答案: 【递归】

125、 问题:课程中的算式是具有满足一定___的组成元素和结构的数据，不是简单的符号串。
答案: 【约束】

126、 问题:模块的独立程度可以由两个定性标准来度量，它们是内聚和_。
答案: 【耦合】

127、 问题:依据模块化理论，_是对一个模块内部各个组成元素之间相互结合的紧密程度的度量指标。
答案: 【内聚】

128、 问题:依据模块化理论，______是一个模块与系统内其他模块及外部世界的关联程度的度量。
答案: 【耦合性】

129、 问题:根据模块化理论，若一组函数通过参数表传递记录信息，这组函数模块之间的耦合就是_____耦合。
答案: 【标记】

130、 问题:__是根据程序的出错情况，分析、猜测可能出现错误的程序区域，让程序运行，观察程序的变化来发现错误的根源。
答案: 【调试】

131、 问题:程序中的每个功能可以由__来验证操作的正确性，它也是软件构造的一项重要活动。
答案: 【测试】

132、 问题: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划分成有效等价区间，最经济的测试数据是多少个？
答案: 【12】
分析：【m的取值：分区各取一个，超出范围的右边一个、左边一个】

133、 问题:Java程序要使用包中的一个类，是在程序前面使用关键字（）来引入该类。
答案: 【import】

134、 问题:public class ThisTester { static int value = 2020; public static void main(String[] args) throws Exception{ new ThisTester().printValue(); } private void printValue(){ int value = 20; System.out.println(this.value); }}代码运行的结果是()。
答案: 【2020】

135、 问题:在Java中，语句for (int i=0;i<50; i++)执循环的次数是（）。
答案: 【50】

136、 问题:public class BMI { public String toString(double weight, double height){ double b = weight/(height*height); if(b < 20) return “偏瘦”; else if(b < 25) return “正常”; else if(b < 30) return “偏胖”; else if(b < 35) return “肥胖”; else if(b < 40) return “重度肥胖”; else return “极度肥胖”; }}输入分别是55.0和1.62，返回结果是（）。
答案: 【正常】

137、 问题:public class BMI { public String toString(double weight, double height){ double b = weight/(height*height); if(b < 20) return “偏瘦”; else if(b < 25) return “正常”; else if(b < 30) return “偏胖”; else if(b < 35) return “肥胖”; else if(b < 40) return “重度肥胖”; else return “极度肥胖”; }}输入55.0,1.75，返回结果是（）。
答案: 【偏瘦】

138、 问题:public class BMI { public String toString(double weight, double height){ double b = weight/(height*height); if(b < 20) return “偏瘦”; else if(b < 25) return “正常”; else if(b < 30) return “偏胖”; else if(b < 35) return “肥胖”; else if(b < 40) return “重度肥胖”; else return “极度肥胖”; }}输入75.0,1.70，返回结果是（）。
答案: 【偏胖】

139、 问题:下列Java语句序列执行后，k 的值是_____。int i=6,j=8,k=10,m=7; if(i>j||m10】

【作业】第 3 章 面向对象的软件构造 构造任务3.2：面向对象构造加法、减法、加减混合50道题

1、 问题:形式：源代码+简单的文档，一个打包文件夹文件名：班级号-姓名[-姓名]-阶段（或构造）序号，文件名举例：软件创新班-张三-李四-阶段1文件夹内容：（1）实验报告文件（word） 同上文件夹名，主要内容是分析、设计、验证（测试或结果抓屏）和讨论；（2）工程或代码以及测试数据、结果抓图等文件 1-3人一个小组，每个小组成绩一样任务构造3.2：30+3或者任务构造3.1：25+3内容：在构造任务2.5基础上用面向对象构造技术，实现运算数、运算结果值的范围都在[0.100]的加法、减法、加减混合50道题验证：分别输出符合要求的50道加法、减法、加减混合题个2套，美观输出；
评分规则: 【 没有语法错误、通过编译，包含有抽象类和继承，即实现设计二，最多15分；如果没有体现抽象类和继承，即实现设计一，最多得10分；
三种练习，每种提供2个测试抓屏：1.5*6=9分
编码风格，名称有意义、规范，排版优雅，注释恰当
实验报告结构完整、表达清楚、容易阅读
在产生50道加减混合题时、如果能让用户选择加法题数量（或者%）、或者减法题数量（或者%）
】

【作业】第 3 章 面向对象的软件构造 构造任务3.2的补充

1、 问题:学习使用Junit，选择3个不同的方法、每个方法成功和失败各一次，每个测试0.5分（截屏），满分3
评分规则: 【 从实现的代码中，选择3个不同的方法、每个方法成功和失败各一次，截屏
】

第 3 章 面向对象的软件构造 3 面向对象的软件构造测验

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、 问题:（）是类型理论的一个概念，一个名字可以表示多个不同类的实例，只要它们具有某个共同的超类而且相关。
选项：
A:继承
B:封装
C:接口
D:多态
答案: 【多态】

14、 问题:用面向对象开发软件时，通常先设计一个包含基本属性和（）的类。然后，随着类的使用，会发现需要补充、修改甚至细化类及其接口。
选项：
A:方法
B:操作
C:可见性
D:接口
答案: 【方法】

15、 问题:（）是整理知识的一种手段。
选项：
A:模块化
B:封装
C:分类
D:抽象
答案: 【分类】

16、 问题:面向对象中有三种类关系。第一种是普通与特殊（继承），第二种是整体-部分（），即“是成员”关系，第三种是关联，表示没有其他关系的类之间的某种语义依赖。
选项：
A:泛化
B:聚合
C:组成
D:依赖
答案: 【聚合】

17、 问题:Meyer认为程序设计本质上是（）：一个较大问题的功能通过把它们分包到不同元素的设计，而分解成若干较小的问题。
选项：
A:编码
B:抽象
C:分解
D:契约
答案: 【契约】

18、 问题:类的（）提供了外部视角，重在抽象，同时隐藏了它的结构和组成。
选项：
A:接口
B:方法
C:操作
D:属性
答案: 【接口】

19、 问题:（）主要由包括所有适用于类的操作的声明、其他类的声明、变量的声明，以及要完成抽象的异常的声明。
选项：
A:接口
B:方法
C:操作
D:基本
答案: 【接口】

20、 问题:类的接口可以进一步分成4类：公共的,保护的，私有的，（）。
选项：
A:库
B:内部的
C:包
D:外部的
答案: 【包】

21、 问题:在UML中，类是用一个带有类名、可选属性和操作（）表示
选项：
A:菱形
B:圆形
C:梯形
D:矩形
答案: 【矩形】

22、 问题:在UML符号中，（）关系是一端带空心三角形的连线，绘制时从子类到父类，空心三角形一端是父类。
选项：
A:泛化
B:依赖
C:继承
D:组合
答案: 【泛化】

23、 问题:抽象类的子类，必须实现抽象父类定义的抽象方法才能生成对象，即低层的子类依赖高层的、抽象的父类。这种设计思想运用了面向对象技术中的（）原则。
选项：
A:里氏代换
B:单一职责
C:开放封闭
D:依赖倒转
答案: 【依赖倒转】

24、 问题:子类型必须能够替换它们的基类型。这一思想体现了对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。这是（）原则。
选项：
A:单一职责
B:开放封闭
C:里氏代换
D:依赖倒转
答案: 【里氏代换】

25、 问题:不应该强迫客户依赖于它们不用的方法。这是（）原则。
选项：
A:单一职责
B:开放封闭
C:里氏代换
D:接口隔离
答案: 【接口隔离】

26、 问题:面向（）的语言主要通过数据的作用域、文件包等方式保护数据，不让程序的其他部分随意改动内部数据、数据结构中的成员。
选项：
A:对象
B:过程
C:连接
D:模块
答案: 【过程】

27、 问题:类的接口可以进一步分成 4 类:公共的、保护的、私有的、()。
选项：
A:连接的
B:模块的
C:包
D:聚合的
答案: 【包】

28、 问题:（）是一种语义更强的聚合，部分组成整体，不可分割。
选项：
A:耦合
B:联合
C:打包
D:组合
答案: 【组合】

29、 问题:每个编程语言的开发工具包通常都提供基本的（）。
选项：
A:编译器
B:调试器
C:集线器
D:交换器
答案: 【调试器】