3 (p1): 第一部分 软件工程介绍 3 (p1-2): 第1章 软件工程的范畴 4 (p1-3): 1.1 历史方面 6 (p1-4): 1.2 经济方面 7 (p1-5): 1.3 维护性方面 10 (p1-6): 1.4 规格说明和设计阶段 12 (p1-7): 1.5 小组编程方面 13 (p1-8): 1.6 面向对象范型 17 (p1-9): 1.7 术语 18 (p1-10): 本章回顾 18 (p1-11): 进一步阅读指导 19 (p1-12): 思考题 20 (p1-13): 参考文献 23 (p1-14): 第2章 软件过程 24 (p1-15): 2.1 客户、开发人员和用户 25 (p1-16): 2.2 需求阶段 26 (p1-17): 2.2.1 需求阶段测试 26 (p1-18): 2.2.2 需求阶段文档 26 (p1-19): 2.3 规格说明阶段 28 (p1-20): 2.3.1 规格说明阶段测试 29 (p1-21): 2.3.2 规格说明阶段文档 29 (p1-22): 2.4 设计阶段 29 (p1-23): 2.4.1 设计阶段测试 30 (p1-24): 2.6 集成阶段 30 (p1-25): 2.5.2 实现阶段文档 30 (p1-26): 2.6.1 集成阶段测试 30 (p1-27): 2.4.2 设计阶段文档 30 (p1-28): 2.5 实现阶段 30 (p1-29): 2.5.1 实现阶段测试 31 (p1-30): 2.6.2 集成阶段文档 31 (p1-31): 2.7 维护阶段 32 (p1-32): 2.7.1 维护阶段测试 32 (p1-33): 2.7.2 维护阶段文档 32 (p1-34): 2.8 退役 32 (p1-35): 2.9 软件生产中存在的问题:本质的和偶发的 33 (p1-36): 2.9.1 复杂性 35 (p1-37): 2.9.3 可变性 35 (p1-38): 2.9.2 一致性 36 (p1-39): 2.9.4 不可见性 36 (p1-40): 2.9.5 没有银弹吗 37 (p1-41): 2.10 改进软件过程 37 (p1-42): 2.11 能力成熟度模型 40 (p1-43): 2.12 软件过程改进方面的其他努力 40 (p1-44): 2.13 软件过程改进的成本和效益 42 (p1-45): 本章回顾 42 (p1-46): 进一步阅读指导 43 (p1-47): 思考题 44 (p1-48): 参考文献 47 (p1-49): 第3章 软件生命周期模型 47 (p1-50): 3.1 建造-修补模型 48 (p1-51): 3.2 瀑布模型 51 (p1-52): 3.3 快速原型开发模型 52 (p1-53): 3.4 增量模型 54 (p1-54): 3.5 极限编程 56 (p1-55): 3.6 同步-稳定模型 56 (p1-56): 3.7 螺旋模型 60 (p1-57): 3.8 面向对象的生命周期模型 61 (p1-58): 3.9 生命周期模型的比较 62 (p1-59): 思考题 62 (p1-60): 进一步阅读指导 62 (p1-61): 本章回顾 63 (p1-62): 参考文献 65 (p1-63): 第4章 软件小组 65 (p1-64): 4.1 小组组织 66 (p1-65): 4.2 民主小组方法 67 (p1-66): 4.3 传统的主程序员小组方法 68 (p1-67): 4.3.1 纽约时报项目 69 (p1-68): 4.3.2 传统的主程序员小组方法的不实用性 69 (p1-69): 4.4 超越主程序员小组和民主小组 71 (p1-70): 4.5 同步-稳定小组 72 (p1-71): 4.6 极限编程小组 73 (p1-72): 思考题 73 (p1-73): 本章回顾 73 (p1-74): 进一步阅读指导 74 (p1-75): 参考文献 75...

duxiu/initial_release/《面向对象与传统软件工程--（原书第5版）》_11117983.zip

zlibzh/no-category/（美）Stephen R.Schach著；韩松等译, Stephen R. Schach zhu, Han Song, Deng Yingchun, Li Ping [and others] yi, (美)Stephen R.Schach著 , 韩松等译, 沙赫, 韩松, S. R Schach/面向对象与传统软件工程 原书第5版_43556679.pdf

Mian xiang dui xiang yu zhuan tong ruan jian gong cheng: Object-oriented and classical software engineering

面向对象与传统软件工程 Mian xiang dui xiang yu chuan tong ruan jian gong cheng

面向对象与传统软件工程 = Object-oriented and classical software engineering

Object-Oriented and CSoftware Engineering;(美)Stephen R.Schach(著);韩松;邓迎春;李萍

机械工业出版社 Ji xie gong ye chu ban she

China Machine Press

机械工业出版社·北京

Ji suan ji ke xue cong shu, Ji suan ji ke xue cong shu, Yuan shu wei di 5 ban, Beijing, China, 2003

Ji suan ji ke xue cong shu, Di 1 ban, 北京 Beijing, 2003

Ji suan ji ke xue cong shu, Bei jing, 2003

China, People's Republic, China

Bookmarks: p1 (p3): 第一部分 软件工程介绍
p1-2 (p3): 第1章 软件工程的范畴
p1-3 (p4): 1.1 历史方面
p1-4 (p6): 1.2 经济方面
p1-5 (p7): 1.3 维护性方面
p1-6 (p10): 1.4 规格说明和设计阶段
p1-7 (p12): 1.5 小组编程方面
p1-8 (p13): 1.6 面向对象范型
p1-9 (p17): 1.7 术语
p1-10 (p18): 本章回顾
p1-11 (p18): 进一步阅读指导
p1-12 (p19): 思考题
p1-13 (p20): 参考文献
p1-14 (p23): 第2章 软件过程
p1-15 (p24): 2.1 客户、开发人员和用户
p1-16 (p25): 2.2 需求阶段
p1-17 (p26): 2.2.1 需求阶段测试
p1-18 (p26): 2.2.2 需求阶段文档
p1-19 (p26): 2.3 规格说明阶段
p1-20 (p28): 2.3.1 规格说明阶段测试
p1-21 (p29): 2.3.2 规格说明阶段文档
p1-22 (p29): 2.4 设计阶段
p1-23 (p29): 2.4.1 设计阶段测试
p1-24 (p30): 2.6 集成阶段
p1-25 (p30): 2.5.2 实现阶段文档
p1-26 (p30): 2.6.1 集成阶段测试
p1-27 (p30): 2.4.2 设计阶段文档
p1-28 (p30): 2.5 实现阶段
p1-29 (p30): 2.5.1 实现阶段测试
p1-30 (p31): 2.6.2 集成阶段文档
p1-31 (p31): 2.7 维护阶段
p1-32 (p32): 2.7.1 维护阶段测试
p1-33 (p32): 2.7.2 维护阶段文档
p1-34 (p32): 2.8 退役
p1-35 (p32): 2.9 软件生产中存在的问题：本质的和偶发的
p1-36 (p33): 2.9.1 复杂性
p1-37 (p35): 2.9.3 可变性
p1-38 (p35): 2.9.2 一致性
p1-39 (p36): 2.9.4 不可见性
p1-40 (p36): 2.9.5 没有银弹吗
p1-41 (p37): 2.10 改进软件过程
p1-42 (p37): 2.11 能力成熟度模型
p1-43 (p40): 2.12 软件过程改进方面的其他努力
p1-44 (p40): 2.13 软件过程改进的成本和效益
p1-45 (p42): 本章回顾
p1-46 (p42): 进一步阅读指导
p1-47 (p43): 思考题
p1-48 (p44): 参考文献
p1-49 (p47): 第3章 软件生命周期模型
p1-50 (p47): 3.1 建造-修补模型
p1-51 (p48): 3.2 瀑布模型
p1-52 (p51): 3.3 快速原型开发模型
p1-53 (p52): 3.4 增量模型
p1-54 (p54): 3.5 极限编程
p1-55 (p56): 3.6 同步-稳定模型
p1-56 (p56): 3.7 螺旋模型
p1-57 (p60): 3.8 面向对象的生命周期模型
p1-58 (p61): 3.9 生命周期模型的比较
p1-59 (p62): 思考题
p1-60 (p62): 进一步阅读指导
p1-61 (p62): 本章回顾
p1-62 (p63): 参考文献
p1-63 (p65): 第4章 软件小组
p1-64 (p65): 4.1 小组组织
p1-65 (p66): 4.2 民主小组方法
p1-66 (p67): 4.3 传统的主程序员小组方法
p1-67 (p68): 4.3.1 纽约时报项目
p1-68 (p69): 4.3.2 传统的主程序员小组方法的不实用性
p1-69 (p69): 4.4 超越主程序员小组和民主小组
p1-70 (p71): 4.5 同步-稳定小组
p1-71 (p72): 4.6 极限编程小组
p1-72 (p73): 思考题
p1-73 (p73): 本章回顾
p1-74 (p73): 进一步阅读指导
p1-75 (p74): 参考文献
p1-76 (p75): 第5章 软件工程工具
p1-77 (p75): 5.1 逐步求精法
p1-78 (p75): 逐步求精法示例
p1-79 (p79): 5.2 成本-效益分析法
p1-80 (p80): 5.3 软件度量
p1-81 (p81): 5.4 CASE
p1-82 (p82): 5.5 CASE的分类
p1-83 (p83): 5.6 CASE的范围
p1-84 (p86): 5.7.1 修订版
p1-85 (p86): 5.7 软件版本
p1-86 (p87): 5.7.2 变种版
p1-87 (p87): 5.8 配置控制
p1-88 (p89): 5.8.1 产品维护期间的配置控制
p1-89 (p89): 5.8.2 基线
p1-90 (p89): 5.8.3 产品开发过程中的配置控制
p1-91 (p90): 5.9 建造工具
p1-92 (p90): 5.10 使用CASE技术提高生产率
p1-93 (p91): 本章回顾
p1-94 (p92): 进一步阅读指导
p1-95 (p92): 思考题
p1-96 (p93): 参考文献
p1-97 (p97): 第6章 测试
p1-98 (p98): 6.1 质量问题
p1-99 (p98): 6.1.1 软件质量保证
p1-100 (p98): 6.1.2 管理独立
p1-101 (p99): 6.2 非执行测试
p1-102 (p99): 6.2.1 走查
p1-103 (p99): 6.2.2 管理走查
p1-104 (p100): 6.2.3 审查
p1-105 (p102): 6.2.4 审查与走查的对比
p1-106 (p102): 6.2.5 评审的长处和短处
p1-107 (p102): 6.2.6 评审的度量
p1-108 (p102): 6.3 执行测试
p1-109 (p103): 6.4 应该测试什么
p1-110 (p104): 6.4.1 实用性
p1-111 (p104): 6.4.2 可靠性
p1-112 (p104): 6.4.3 健壮性
p1-113 (p105): 6.4.4 性能
p1-114 (p105): 6.4.5 正确性
p1-115 (p106): 6.5 测试与正确性证明
p1-116 (p107): 6.5.1 正确性证明的例子
p1-117 (p109): 6.5.2 正确性证明案例研究
p1-118 (p110): 6.5.3 正确性证明和软件工程
p1-119 (p112): 6.6 谁来完成执行测试
p1-120 (p113): 进一步阅读指导
p1-121 (p113): 本章回顾
p1-122 (p113): 6.7 何时停止测试
p1-123 (p114): 思考题
p1-124 (p115): 参考文献
p1-125 (p119): 第7章 从模块到对象
p1-126 (p119): 7.1 什么是模块
p1-127 (p121): 7.2 内聚
p1-128 (p122): 7.2.1 偶然性内聚
p1-129 (p122): 7.2.2 逻辑性内聚
p1-130 (p123): 7.2.3 时间性内聚
p1-131 (p123): 7.2.4 过程性内聚
p1-132 (p123): 7.2.5 通信性内聚
p1-133 (p124): 7.2.7 信息性内聚
p1-134 (p124): 7.2.6 功能性内聚
p1-135 (p125): 7.2.8 内聚示例
p1-136 (p125): 7.3 耦合
p1-137 (p126): 7.3.1 内容耦合
p1-138 (p126): 7.3.2 共用耦合
p1-139 (p127): 7.3.3 控制耦合
p1-140 (p128): 7.3.4 印记耦合
p1-141 (p128): 7.3.5 数据耦合
p1-142 (p129): 7.3.6 耦合示例
p1-143 (p130): 7.3.7 耦合的重要性
p1-144 (p130): 7.4 数据封装
p1-145 (p132): 7.4.1 数据封装和产品开发
p1-146 (p133): 7.4.2 数据封装和产品维护
p1-147 (p138): 7.5 抽象数据类型
p1-148 (p139): 7.6 信息隐藏
p1-149 (p141): 7.7 对象
p1-150 (p143): 7.8 继承、多态和动态绑定
p1-151 (p145): 7.9 对象的内聚和耦合
p1-152 (p145): 7.10 面向对象范型
p1-153 (p147): 本章回顾
p1-154 (p147): 进一步阅读指导
p1-155 (p148): 思考题
p1-156 (p149): 参考文献
p1-157 (p151): 8.1 复用的概念
p1-158 (p151): 第8章 可复用性、可移植性和互操作性
p1-159 (p152): 8.2 复用的障碍
p1-160 (p153): 8.3 复用案例研究
p1-161 (p153): 8.3.1 Raytheon导弹系统部
p1-162 (p155): 8.3.2 东芝软件工厂
p1-163 (p155): 8.3.3 NASA软件
p1-164 (p156): 8.3.4 GTE数据服务
p1-165 (p156): 8.3.5 惠普公司
p1-166 (p157): 8.3.6 欧洲航天局
p1-167 (p158): 8.4 对象和复用
p1-168 (p158): 8.5 设计和实现阶段的复用
p1-169 (p158): 8.5.1 设计复用
p1-170 (p159): 8.5.2 应用框架
p1-171 (p160): 8.5.3 设计模式
p1-172 (p162): 8.5.4 软件体系结构
p1-173 (p164): 8.6 复用和维护
p1-174 (p164): 8.7 可移植性
p1-175 (p165): 8.7.1 硬件的不兼容性
p1-176 (p165): 8.7.2 操作系统的不兼容性
p1-177 (p166): 8.7.3 数值计算软件的不兼容性
p1-178 (p167): 8.7.4 编译器的不兼容性
p1-179 (p170): 8.8 为什么需要可移植性
p1-180 (p171): 8.9 实现可移植性的技术
p1-181 (p171): 8.9.1 可移植的系统软件
p1-182 (p172): 8.9.2 可移植的应用软件
p1-183 (p173): 8.9.3 可移植的数据
p1-184 (p173): 8.10 互操作性
p1-185 (p173): 8.10.1 COM
p1-186 (p174): 8.10.2 CORBA
p1-187 (p174): 8.10.3 COM和CORBA的比较
p1-188 (p175): 8.11 互操作性的未来趋势
p1-189 (p175): 本章回顾
p1-190 (p176): 进一步阅读指导
p1-191 (p177): 思考题
p1-192 (p179): 参考文献
p1-193 (p185): 第9章 计划和估算
p1-194 (p185): 9.1 计划和软件过程
p1-195 (p186): 9.2 周期和成本估算
p1-196 (p187): 9.2.1 产品规模的度量
p1-197 (p190): 9.2.2 成本估算的技术
p1-198 (p192): 9.2.3 中间COCOMO
p1-199 (p194): 9.2.4 COCOM0Ⅱ
p1-200 (p195): 9.2.5 跟踪周期和成本估算
p1-201 (p195): 9.3 软件项目管理计划的组成
p1-202 (p196): 9.4 软件项目管理计划框架
p1-203 (p197): 9.5 IEEE软件项目管理计划
p1-204 (p198): 9.6 测试计划
p1-205 (p199): 9.7 计划面向对象的项目
p1-206 (p200): 9.9 文档标准
p1-207 (p200): 9.8 培训需求
p1-208 (p201): 9.10 用于计划和估算的CASE工具
p1-209 (p201): 9.11 测试软件项目管理计划
p1-210 (p201): 本章回顾
p1-211 (p201): 进一步阅读指导
p1-212 (p202): 思考题
p1-213 (p203): 参考文献
p2 (p209): 第二部分 软件生命周期的各个阶段
p2-2 (p209): 第10章 需求阶段
p2-3 (p209): 10.1 需求获取
p2-4 (p210): 10.1.1 访谈
p2-5 (p210): 10.1.2 情景
p2-6 (p211): 10.1.3 其他需求获取技术
p2-7 (p212): 10.2 需求分析
p2-8 (p212): 10.3 快速原型开发
p2-9 (p213): 10.4 人的因素
p2-10 (p215): 10.5 作为一种规格说明技术的快速原型开发
p2-11 (p216): 10.6 复用快速原型
p2-12 (p217): 10.7 快速原型开发模型的管理含意
p2-13 (p218): 10.8 快速原型开发的试验
p2-14 (p219): 10.9 需求获取和需求分析技术
p2-15 (p220): 10.10 在需求分析阶段测试
p2-16 (p220): 10.11 需求阶段的CASE工具
p2-17 (p221): 10.13 面向对象的需求
p2-18 (p221): 10.12 需求阶段的度量
p2-19 (p222): 10.14 “空中美食”案例研究：需求阶段
p2-20 (p224): 10.15 “空中美食”案例研究：快速原型
p2-21 (p225): 10.16 需求阶段面临的挑战
p2-22 (p226): 本章回顾
p2-23 (p227): 进一步阅读指导
p2-24 (p227): 思考题
p2-25 (p228): 参考文献
p2-26 (p231): 第11章 规格说明阶段
p2-27 (p231): 11.1 规格说明文档
p2-28 (p232): 11.2 非形式化规格说明
p2-29 (p233): 案例研究：文本处理
p2-30 (p233): 11.3 结构化系统分析
p2-31 (p234): Sally的软件商店
p2-32 (p239): 11.4 其他半形式化的技术
p2-33 (p240): 11.5 建造实体-关系模型
p2-34 (p241): 11.6 有限状态机
p2-35 (p243): 电梯问题：有限状态机
p2-36 (p246): 11.7 Petri网
p2-37 (p250): 11.8 Z规格说明语言
p2-38 (p250): 11.8.1 电梯问题：Z规格说明
p2-39 (p252): 11.8.2 Z的分析
p2-40 (p253): 11.9 其他形式化技术
p2-41 (p253): 11.10 规格说明技术的比较
p2-42 (p254): 11.11 在规格说明阶段测试
p2-43 (p255): 11.12 规格说明阶段的CASE工具
p2-44 (p255): 11.13 规格说明阶段的度量
p2-45 (p255): 11.14 “空中美食”案例研究：结构化系统分析
p2-46 (p257): 11.15 “空中美食”案例研究：软件项目管理计划
p2-47 (p257): 11.16 规格说明阶段面临的挑战
p2-48 (p258): 本章回顾
p2-49 (p258): 进一步阅读指导
p2-50 (p259): 思考题
p2-51 (p261): 参考文献
p2-52 (p265): 第12章 面向对象分析阶段
p2-53 (p265): 12.1 面向对象分析
p2-54 (p267): 12.3 用例建模
p2-55 (p267): 12.2 电梯问题：面向对象分析
p2-56 (p268): 12.4 类建模
p2-57 (p269): 12.4.1 名词提取
p2-58 (p270): 12.4.2 CRC卡片
p2-59 (p271): 12.5 动态建模
p2-60 (p273): 12.6 在面向对象分析阶段测试
p2-61 (p276): 12.7 面向对象分析阶段的CASE工具
p2-62 (p276): 12.8 “空中美食”案例研究：面向对象分析
p2-63 (p281): 12.9 面向对象分析阶段面临的挑战
p2-64 (p281): 本章回顾
p2-65 (p281): 进一步阅读指导
p2-66 (p282): 思考题
p2-67 (p283): 参考文献
p2-68 (p285): 第13章 设计阶段
p2-69 (p285): 13.1 设计和抽取
p2-70 (p286): 13.2 面向行为设计
p2-71 (p286): 13.3 数据流分析
p2-72 (p287): 13.3.1 数据流分析示例
p2-73 (p290): 13.3.2 扩展
p2-74 (p291): 13.4 事务分析
p2-75 (p292): 13.5 面向数据设计
p2-76 (p292): 13.6 面向对象设计
p2-77 (p293): 13.7 电梯问题：面向对象设计
p2-78 (p299): 13.8 详细设计的形式化技术
p2-79 (p299): 13.9 实时设计技术
p2-80 (p300): 13.10 设计期间的测试
p2-81 (p301): 13.11 设计阶段的CASE工具
p2-82 (p301): 13.12 设计阶段的度量
p2-83 (p302): 13.13 “空中美食”案例研究：面向对象设计
p2-84 (p308): 13.14 设计阶段面临的挑战
p2-85 (p309): 本章回顾
p2-86 (p309): 进一步阅读指导
p2-87 (p309): 思考题
p2-88 (p310): 参考文献
p2-89 (p313): 第14章 实现阶段
p2-90 (p313): 14.1 编程语言的选择
p2-91 (p315): 14.2 第四代语言
p2-92 (p317): 14.3 良好的编程习惯
p2-93 (p321): 14.4 编码标准
p2-94 (p322): 14.5 模块复用
p2-95 (p322): 14.6 模块测试用例选择
p2-96 (p322): 14.6.1 规格说明测试与代码测试
p2-97 (p323): 14.6.2 规格说明测试的可行性
p2-98 (p323): 14.6.3 代码测试的可行性
p2-99 (p325): 14.7 黑盒模块测试技术
p2-100 (p325): 14.7.1 等价测试和边界值测试
p2-101 (p326): 14.7.2 功能测试
p2-102 (p327): 14.8 玻璃盒模块测试技术
p2-103 (p327): 14.8.1 结构测试：语句覆盖、分支覆盖以及路径覆盖
p2-104 (p328): 14.8.2 复杂性度量
p2-105 (p330): 14.10 模块测试技术的比较
p2-106 (p330): 14.9 代码走查和审查
p2-107 (p331): 14.11 净室
p2-108 (p332): 14.12 测试对象时潜在的问题
p2-109 (p334): 14.13 模块测试的管理方面
p2-110 (p334): 14.14 何时该重写而不是调试一个模块
p2-111 (p335): 14.15 实现阶段的CASE工具
p2-112 (p335): 14.16 “空中美食”案例研究：黑盒测试用例
p2-113 (p337): 14.17 实现阶段面临的挑战
p2-114 (p337): 本章回顾
p2-115 (p337): 进一步阅读指导
p2-116 (p338): 思考题
p2-117 (p339): 参考文献
p2-118 (p343): 15.1 实现与集成介绍
p2-119 (p343): 第15章 实现与集成阶段
p2-120 (p344): 15.1.1 自顶向下的实现与集成
p2-121 (p345): 15.1.2 自底向上的实现与集成
p2-122 (p345): 15.1.3 三明治式实现与集成
p2-123 (p347): 15.1.4 面向对象产品的实现与集成
p2-124 (p347): 15.1.5 实现与集成阶段的管理问题
p2-125 (p347): 15.2 实现与集成期间的测试
p2-126 (p348): 15.3 图形用户界面的集成测试
p2-127 (p348): 15.4 产品测试
p2-128 (p349): 15.5 验收测试
p2-129 (p350): 15.8 集成化开发环境
p2-130 (p350): 15.6 实现与集成阶段的CASE工具
p2-131 (p350): 15.7 软件开发全过程的CASE工具
p2-132 (p351): 15.9 商业应用软件开发环境
p2-133 (p352): 15.10 公共工具基础结构
p2-134 (p352): 15.11 开发环境的潜在问题
p2-135 (p352): 15.12 实现与集成阶段的度量
p2-136 (p353): 15.13 “空中美食”案例研究：实现与集成阶段
p2-137 (p353): 15.14 实现与集成阶段面临的挑战
p2-138 (p353): 本章回顾
p2-139 (p353): 进一步阅读指导
p2-140 (p354): 思考题
p2-141 (p355): 参考文献
p2-142 (p357): 16.1 维护的必要性
p2-143 (p357): 第16章 维护阶段
p2-144 (p358): 16.2 对维护程序员的要求
p2-145 (p359): 16.3 维护工作案例研究
p2-146 (p360): 16.4 维护管理
p2-147 (p360): 16.4.1 错误报告
p2-148 (p361): 16.4.2 批准对产品的修改
p2-149 (p362): 16.4.3 确保软件的可维护性
p2-150 (p362): 16.4.4 反复维护造成的问题
p2-151 (p363): 16.5 面向对象软件的维护
p2-152 (p365): 16.6 维护技能与开发技能
p2-153 (p365): 16.7 逆向工程
p2-154 (p366): 16.9 维护阶段的CASE工具
p2-155 (p366): 16.8 维护阶段的测试
p2-156 (p367): 16.10 维护阶段的度量
p2-157 (p367): 16.11 “空中美食”案例研究：维护阶段
p2-158 (p367): 16.12 维护阶段面临的挑战
p2-159 (p368): 本章小结
p2-160 (p368): 进一步阅读指导
p2-161 (p368): 思考题
p2-162 (p369): 参考文献
p3 (p375): 附录
p3-2 (p375): 附录A Broadlands地区儿童医院
p3-3 (p379): 附录B 软件工程资料
p3-4 (p381): 附录C “空中美食”案例研究：C快速原型
p3-5 (p382): 附录D “空中美食”案例研究：Java快速原型
p3-6 (p383): 附录E “空中美食”案例研究：结构化系统分析
p3-7 (p389): 附录F “空中美食”案例研究：软件项目管理计划
p3-8 (p393): 附录G “空中美食”案例研究：面向对象的分析
p3-9 (p394): 附录H “空中美食”案例研究：C++实现的设计
p3-10 (p407): 附录I “空中美食”案例研究：Java实现的设计
p3-11 (p419): 附录J “空中美食”案例研究：黑盒测试用例
p3-12 (p424): 附录K “空中美食”案例研究：C++源代码
p3-13 (p425): 附录L “空中美食”案例研究：Java源代码
p3-14 (p427): 参考文献
p3-15 (p451): 索引

related_files:
filepath:/读秀/DX/2.0/2.0等多个文件/843_28_7a/其余书库等多个文件/843_28_7a/132-163/09-163/《面向对象与传统软件工程--(原书第5版)》_11117983.zip
filepath:《面向对象与传统软件工程--(原书第5版)》_11117983.zip — md5:9696a0110ed1f6149d42c33e49a3439a — filesize:51200499
filepath:《面向对象与传统软件工程--(原书第5版)》_11117983.zip — md5:f5b8f741c3cfd557c1221044e7fdbf49 — filesize:51200499
filepath:面向对象与传统软件工程_11117983.zip — md5:fd8e102d7813dcde5aac7c2b49e3d591 — filesize:51156063
filepath:11117983.rar — md5:83963f5b66fad0152640407880d09565 — filesize:51079228
filepath:11117983.zip — md5:0ff2b3731v3d6dfe488006fd14e90ed1 — filesize:51200499
filepath:/读秀/读秀4.0/读秀/4.0/数据库15-1/《面向对象与传统软件工程--(原书第5版)》_11117983.zip
filepath:843_28_6c/09-163/《面向对象与传统软件工程--(原书第5版)》_11117983.zip
filepath:第二部分/200716/BBB‘/70/11117983.zip
filepath:第三部分/BBB‘/70/11117983.zip

Includes bibliographical references and index.

subject: 软件工程

contributor: 浙江大学

contributor: 李萍

format: Image/Djvu(.djvu)

relation: 计算机科学丛书

rights: 限于校园网用户

unit_name: 浙江大学

guancang_unit: 06

fenlei: TP311.5 /CS12

topic: 软件工程

Type: 当代图书

Bookmarks:
1. (p1) 第一部分 软件工程介绍
1.1. (p3) 第1章软件工程的范畴
1.1.1. (p4) 1．1历史方面
1.1.2. (p6) 1．2经济方面
1.1.3. (p7) 1．3维护性方面
1.1.4. (p10) 1．4规格说明和设计阶段
1.1.5. (p12) 1．5小组编程方面
1.1.6. (p13) 1．6面向对象范型
1.1.7. (p17) 1．7术语
1.1.8. (p18) 本章回顾
1.1.9. (p18) 进一步阅读指导
1.1.10. (p19) 思考题
1.1.11. (p20) 参考文献
1.2. (p23) 第2章软件过程
1.2.1. (p24) 2．1客户、开发人员和用户
1.2.2. (p25) 2．2需求阶段
1.2.3. (p26) 2．3规格说明阶段
1.2.4. (p29) 2．4设计阶段
1.2.5. (p30) 2．5实现阶段
1.2.6. (p30) 2．6集成阶段
1.2.7. (p31) 2．7维护阶段
1.2.8. (p32) 2．8退役
1.2.9. (p32) 2．9软件生产中存在的问题：本质的和偶发的
1.2.10. (p37) 2．10改进软件过程
1.2.11. (p37) 2．11能力成熟度模型
1.2.12. (p40) 2．12软件过程改进方面的其他努力
1.2.13. (p40) 2．13软件过程改进的成本和效益
1.2.14. (p42) 本章回顾
1.2.15. (p42) 进一步阅读指导
1.2.16. (p43) 思考题
1.2.17. (p44) 参考文献
1.3. (p47) 第3章软件生命周期模型
1.3.1. (p47) 3．1建造-修补模型
1.3.2. (p48) 3．2瀑布模型
1.3.3. (p51) 3．3快速原型开发模型
1.3.4. (p52) 3．4增量模型
1.3.5. (p54) 3．5极限编程
1.3.6. (p56) 3．6同步-稳定模型
1.3.7. (p56) 3．7螺旋模型
1.3.8. (p60) 3．8面向对象的生命周期模型
1.3.9. (p61) 3．9生命周期模型的比较
1.3.10. (p62) 本章回顾
1.3.11. (p62) 进一步阅读指导
1.3.12. (p62) 思考题
1.3.13. (p63) 参考文献
1.4. (p65) 第4章软件小组
1.4.1. (p65) 4．1小组组织
1.4.2. (p66) 4．2民主小组方法
1.4.3. (p67) 4．3传统的主程序员小组方法
1.4.4. (p69) 4．4超越主程序员小组和民主小组
1.4.5. (p71) 4．5同步-稳定小组
1.4.6. (p72) 4．6极限编程小组
1.4.7. (p73) 本章回顾
1.4.8. (p73) 进一步阅读指导
1.4.9. (p73) 思考题
1.4.10. (p74) 参考文献
1.5. (p75) 第5章软件工程工具
1.5.1. (p75) 5．1逐步求精法
1.5.2. (p79) 5．2成本-效益分析法
1.5.3. (p80) 5．3软件度量
1.5.4. (p81) 5．4CASE
1.5.5. (p82) 5．5CASE的分类
1.5.6. (p83) 5．6CASE的范围
1.5.7. (p86) 5．7软件版本
1.5.8. (p87) 5．8配置控制
1.5.9. (p90) 5．9建造工具
1.5.10. (p90) 5．10使用CASE技术提高生产率
1.5.11. (p91) 本章回顾
1.5.12. (p92) 进一步阅读指导
1.5.13. (p92) 思考题
1.5.14. (p93) 参考文献
1.6. (p97) 第6章测试
1.6.1. (p98) 6．1质量问题
1.6.2. (p99) 6．2非执行测试
1.6.3. (p102) 6．3执行测试
1.6.4. (p103) 6．4应该测试什么
1.6.5. (p106) 6．5测试与正确性证明
1.6.6. (p112) 6．6谁来完成执行测试
1.6.7. (p113) 6．7何时停止测试
1.6.8. (p113) 本章回顾
1.6.9. (p113) 进一步阅读指导
1.6.10. (p114) 思考题
1.6.11. (p115) 参考文献
1.7. (p119) 第7章从模块到对象
1.7.1. (p119) 7．1什么是模块
1.7.2. (p121) 7．2内聚
1.7.3. (p125) 7．3耦合
1.7.4. (p130) 7．4数据封装
1.7.5. (p138) 7．5抽象数据类型
1.7.6. (p139) 7．6信息隐藏
1.7.7. (p141) 7．7对象
1.7.8. (p143) 7．8继承、多态和动态绑定
1.7.9. (p145) 7．9对象的内聚和耦合
1.7.10. (p145) 7．10面向对象范型
1.7.11. (p147) 本章回顾
1.7.12. (p147) 进一步阅读指导
1.7.13. (p148) 思考题
1.7.14. (p149) 参考文献
1.8. (p151) 第8章可复用性、可移植性和互操作性
1.8.1. (p151) 8．1复用的概念
1.8.2. (p152) 8．2复用的障碍
1.8.3. (p153) 8．3复用案例研究
1.8.4. (p158) 8．4对象和复用
1.8.5. (p158) 8．5设计和实现阶段的复用
1.8.6. (p164) 8．6复用和维护
1.8.7. (p164) 8．7可移植性
1.8.8. (p170) 8．8为什么需要可移植性
1.8.9. (p171) 8．9实现可移植性的技术
1.8.10. (p173) 8．10互操作性
1.8.11. (p175) 8．11互操作性的未来趋势
1.8.12. (p175) 本章回顾
1.8.13. (p176) 进一步阅读指导
1.8.14. (p177) 思考题
1.8.15. (p179) 参考文献
1.9. (p185) 第9章计划和估算
2. (p207) 第二部分 软件生命周期的各个阶段
2.1. (p209) 第10章需求阶段
2.1.1. (p209) 10．1需求获取
2.1.2. (p212) 10．2需求分析
2.1.3. (p212) 10．3快速原型开发
2.1.4. (p213) 10．4人的因素
2.1.5. (p215) 10．5作为一种规格说明技术的快速原型开发
2.1.6. (p216) 10．6复用快速原型
2.1.7. (p217) 10．7快速原型开发模型的管理含意
2.1.8. (p218) 10．8快速原型开发的试验
2.1.9. (p219) 10．9需求获取和需求分析技术
2.1.10. (p220) 10．10在需求分析阶段测试
2.1.11. (p220) 10．1l需求阶段的CASE工具
2.1.12. (p221) 10．12需求阶段的度量
2.1.13. (p221) 10．13面向对象的需求
2.1.14. (p222) 10．14“空中美食”案例研究：需求阶段
2.1.15. (p224) 10．15“空中美食”案例研究：快速原型
2.1.16. (p225) 10．16需求阶段面临的挑战
2.1.17. (p226) 本章回顾
2.1.18. (p227) 进一步阅读指导
2.1.19. (p227) 思考题
2.1.20. (p228) 参考文献
2.2. (p231) 第11章规格说明阶段
2.2.1. (p231) 11．1规格说明文档
2.2.2. (p232) 11．2非形式化规格说明
2.2.3. (p233) 11．3结构化系统分析
2.2.4. (p239) 11．4其他半形式化的技术
2.2.5. (p240) 11．5建造实体-关系模型
2.2.6. (p241) 11．6有限状态机
2.2.7. (p246) 11．7Petri网
2.2.8. (p250) 11．8Z规格说明语言
2.2.9. (p253) 11．9其他形式化技术
2.2.10. (p253) 11．10规格说明技术的比较
2.2.11. (p254) 11．11在规格说明阶段测试
2.2.12. (p255) 11．12规格说明阶段的CASE工具
2.2.13. (p255) 11．13规格说明阶段的度量
2.2.14. (p255) 11．14“空中美食"案例研究：结构化系统分析
2.2.15. (p257) 11．15“空中美食”案例研究：软件项目管理计划
2.2.16. (p257) 11．16规格说明阶段面临的挑战
2.2.17. (p258) 本章回顾
2.2.18. (p258) 进一步阅读指导
2.2.19. (p259) 思考题
2.2.20. (p261) 参考文献
2.3. (p265) 第12章面向对象分析阶段
2.3.1. (p265) 12．1面向对象分析
2.3.2. (p267) 12．2电梯问题：面向对象分析
2.3.3. (p267) 12．3用例建模
2.3.4. (p268) 12．4类建模
2.3.5. (p271) 12．5动态建模
2.3.6. (p273) 12．6在面向对象分析阶段测试
2.3.7. (p276) 12．7面向对象分析阶段的CASE工具
2.3.8. (p276) 12．8“空中美食”案例研究：面向对象分析
2.3.9. (p281) 12．9面向对象分析阶段面临的挑战
2.3.10. (p281) 本章回顾
2.3.11. (p281) 进一步阅读指导
2.3.12. (p282) 思考题
2.3.13. (p283) 参考文献
2.4. (p285) 第13章设计阶段
2.4.1. (p285) 13．1设计和抽取
2.4.2. (p286) 13．2面向行为设计
2.4.3. (p286) 13．3数据流分析
2.4.4. (p291) 13．4事务分析
2.4.5. (p292) 13．5面向数据设计
2.4.6. (p292) 13．6面向对象设计
2.4.7. (p293) 13．7电梯问题：面向对象设计
2.4.8. (p299) 13．8详细设计的形式化技术
2.4.9. (p299) 13．9实时设计技术
2.4.10. (p300) 13．10设计期间的测试
2.4.11. (p301) 13．11设计阶段的CASE工具
2.4.12. (p301) 13．12设计阶段的度量
2.4.13. (p302) 13．13“空中美食"案例研究：面向对象设计
2.4.14. (p308) 13．14设计阶段面临的挑战
2.4.15. (p309) 本章回顾
2.4.16. (p309) 进一步阅读指导
2.4.17. (p309) 思考题
2.4.18. (p310) 参考文献
2.5. (p313) 第14章实现阶段
2.5.1. (p313) 14．1编程语言的选择
2.5.2. (p315) 14．2第四代语言
2.5.3. (p317) 14．3良好的编程习惯
2.5.4. (p321) 14．4编码标准
2.5.5. (p322) 14．5模块复用
2.5.6. (p322) 14．6模块测试用例选择
2.5.7. (p325) 14．7黑盒模块测试技术
2.5.8. (p327) 14．8玻璃盒模块测试技术
2.5.9. (p330) 14．9代码走查和审查
2.5.10. (p330) 14．10模块测试技术的比较
2.5.11. (p331) 14．11净室
2.5.12. (p332) 14．12测试对象时潜在的问题
2.5.13. (p334) 14．13模块测试的管理方面
2.5.14. (p334) 14．14何时该重写而不是调试一个模块
2.5.15. (p335) 14．15实现阶段的CASE工具
2.5.16. (p335) 14．16“空中美食”案例研究：黑盒测试用例
2.5.17. (p337) 14．17实现阶段面临的挑战
2.5.18. (p337) 本章回顾
2.5.19. (p337) 进一步阅读指导
2.5.20. (p338) 思考题
2.5.21. (p339) 参考文献
2.6. (p343) 第15章实现与集成阶段
2.6.1. (p343) 15．1实现与集成介绍
2.6.2. (p347) 15．2实现与集成期间的测试
2.6.3. (p348) 15．3图形用户界面的集成测试
2.6.4. (p348) 15．4产品测试
2.6.5. (p349) 15．5验收测试
2.6.6. (p350) 15．6实现与集成阶段的CASE工具
2.6.7. (p350) 15．7软件开发全过程的CASE工具
2.6.8. (p350) 15．8集成化开发环境
2.6.9. (p351) 15．9商业应用软件开发环境
2.6.10. (p352) 15．10公共工具基础结构
2.6.11. (p352) 15．11开发环境的潜在问题
2.6.12. (p352) 15．12实现与集成阶段的度量
2.6.13. (p353) 15．13“空中美食”案例研究：实现与集成阶段
2.6.14. (p353) 15．14实现与集成阶段面临的挑战
2.6.15. (p353) 本章回顾
2.6.16. (p353) 进一步阅读指导
2.6.17. (p354) 思考题
2.6.18. (p355) 参考文献
2.7. (p357) 第16章维护阶段
2.7.1. (p357) 16．1维护的必要性
2.7.2. (p358) 16．2对维护程序员的要求
2.7.3. (p359) 16．3维护工作案例研究
2.7.4. (p360) 16．4维护管理
2.7.5. (p363) 16．5面向对象软件的维护
2.7.6. (p365) 16．6维护技能与开发技能
2.7.7. (p365) 16．7逆向工程
2.7.8. (p366) 16．8维护阶段的测试
2.7.9. (p366) 16．9维护阶段的CASE工具
2.7.10. (p367) 16．10维护阶段的度量
2.7.11. (p367) 16．11“空中美食”案例研究：维护阶段
2.7.12. (p367) 16．12维护阶段面临的挑战
2.7.13. (p368) 本章小结
2.7.14. (p368) 进一步阅读指导
2.7.15. (p368) 思考题
2.7.16. (p369) 参考文献

theme: 软件工程

Type: modern

contributor: 西安交通大学

contributor: 韩松等

rights: 仅限校园网访问

unit_name: 西安交通大学

guancang_unit: 04

fenlei: TP311.5

Bookmarks:
1. (p1) 第一部分 软件工程介绍
1.1. (p3) 第1章　软件工程的范畴
1.1.1. (p4) 1.1　历史方面
1.1.2. (p6) 1.2　经济方面
1.1.3. (p7) 1.3　维护性方面
1.1.4. (p10) 1.4　规格说明和设计阶段
1.1.5. (p12) 1.5　小组编程方面
1.1.6. (p13) 1.6　面向对象范型
1.1.7. (p17) 1.7　术语
1.1.8. (p18) 本章回顾
1.1.9. (p18) 进一步阅读指导
1.1.10. (p19) 思考题
1.1.11. (p20) 参考文献
1.2. (p23) 第2章　软件过程
1.2.1. (p24) 2.1　客户、开发人员和用户
1.2.2. (p25) 2.2　需求阶段
1.2.3. (p26) 2.3　规格说明阶段
1.2.4. (p29) 2.4　设计阶段
1.2.5. (p30) 2.5　实现阶段
1.2.6. (p30) 2.6　集成阶段
1.2.7. (p31) 2.7　维护阶段
1.2.8. (p32) 2.8　退役
1.2.9. (p32) 2.9　软件生产中存在的问题：本质的和偶发的
1.2.10. (p37) 2.10　改进软件过程
1.2.11. (p37) 2.11　能力成熟度模型
1.2.12. (p40) 2.12　软件过程改进方面的其他努力
1.2.13. (p40) 2.13　软件过程改进的成本和效益
1.2.14. (p42) 本章回顾
1.2.15. (p42) 进一步阅读指导
1.2.16. (p43) 思考题
1.2.17. (p44) 参考文献
1.3. (p47) 第3章　软件生命周期模型
1.3.1. (p47) 3.1　建造－修补模型
1.3.2. (p48) 3.2　瀑布模型
1.3.3. (p51) 3.3　快速原型开发模型
1.3.4. (p52) 3.4　增量模型
1.3.5. (p54) 3.5　极限编程
1.3.6. (p56) 3.6　同步－稳定模型
1.3.7. (p56) 3.7　螺旋模型
1.3.8. (p60) 3.8　面向对象的生命周期模型
1.3.9. (p61) 3.9　生命周期模型的比较
1.3.10. (p62) 本章回顾
1.3.11. (p62) 进一步阅读指导
1.3.12. (p62) 思考题
1.3.13. (p63) 参考文献
1.4. (p65) 第4章　软件小组
1.4.1. (p65) 4.1　小组组织
1.4.2. (p66) 4.2　民主小组方法
1.4.3. (p67) 4.3　传统的主程序员小组方法
1.4.4. (p69) 4.4　超越主程序员小组和民主小组
1.4.5. (p71) 4.5　同步－稳定小组
1.4.6. (p72) 4.6　极限编程小组
1.4.7. (p73) 本章回顾
1.4.8. (p73) 进一步阅读指导
1.4.9. (p73) 思考题
1.4.10. (p74) 参考文献
1.5. (p75) 第5章　软件工程工具
1.5.1. (p75) 5.1　逐步求精法
1.5.2. (p79) 5.2　成本－效益分析法
1.5.3. (p80) 5.3　软件度量
1.5.4. (p81) 5.4　CASE
1.5.5. (p82) 5.5　CASE的分类
1.5.6. (p83) 5.6　CASE的范围
1.5.7. (p86) 5.7　软件版本
1.5.8. (p87) 5.8　配置控制
1.5.9. (p90) 5.9　建造工具
1.5.10. (p90) 5.10　使用CASE技术提高生产率
1.5.11. (p91) 本章回顾
1.5.12. (p92) 进一步阅读指导
1.5.13. (p92) 思考题
1.5.14. (p93) 参考文献
1.6. (p97) 第6章　测试
1.6.1. (p98) 6.1　质量问题
1.6.2. (p99) 6.2　非执行测试
1.6.3. (p102) 6.3　执行测试
1.6.4. (p103) 6.4　应该测试什么
1.6.5. (p106) 6.5　测试与正确性证明
1.6.6. (p112) 6.6　谁来完成执行测试
1.6.7. (p113) 6.7　何时停止测试
1.6.8. (p113) 本章回顾
1.6.9. (p113) 进一步阅读指导
1.6.10. (p114) 思考题
1.6.11. (p115) 参考文献
1.7. (p119) 第7章　从模块到对象
1.7.1. (p119) 7.1　什么是模块
1.7.2. (p121) 7.2　内聚
1.7.3. (p125) 7.3　耦合
1.7.4. (p130) 7.4　数据封装
1.7.5. (p138) 7.5　抽象数据类型
1.7.6. (p139) 7.6　信息隐藏
1.7.7. (p141) 7.7　对象
1.7.8. (p143) 7.8　继承、多态和动态绑定
1.7.9. (p145) 7.9　对象的内聚和耦合
1.7.10. (p145) 7.10　面向对象范型
1.7.11. (p147) 本章回顾
1.7.12. (p147) 进一步阅读指导
1.7.13. (p148) 思考题
1.7.14. (p149) 参考文献
1.8. (p151) 第8章　可复用性、可移植性和互操作性
1.8.1. (p151) 8.1　复用的概念
1.8.2. (p152) 8.2　复用的障碍
1.8.3. (p153) 8.3　复用案例研究
1.8.4. (p158) 8.4　对象和复用
1.8.5. (p158) 8.5　设计和实现阶段的复用
1.8.6. (p164) 8.6　复用和维护
1.8.7. (p164) 8.7　可移植性
1.8.8. (p170) 8.8　为什么需要可移植性
1.8.9. (p171) 8.9　实现可移植性的技术
1.8.10. (p173) 8.10　互操作性
1.8.11. (p175) 8.11　互操作性的未来趋势
1.8.12. (p175) 本章回顾
1.8.13. (p176) 进一步阅读指导
1.8.14. (p177) 思考题
1.8.15. (p179) 参考文献
1.9. (p185) 第9章　计划和估算
2. (p207) 第二部分 软件生命周期的各个阶段
2.1. (p209) 第10章　需求阶段
2.1.1. (p209) 10.1　需求获取
2.1.2. (p212) 10.2　需求分析
2.1.3. (p212) 10.3　快速原型开发
2.1.4. (p213) 10.4　人的因素
2.1.5. (p215) 10.5　作为一种规格说明技术的快速原型开发
2.1.6. (p216) 10.6　复用快速原型
2.1.7. (p217) 10.7　快速原型开发模型的管理含意
2.1.8. (p218) 10.8　快速原型开发的试验
2.1.9. (p219) 10.9　需求获取和需求分析技术
2.1.10. (p220) 10.10　在需求分析阶段测试
2.1.11. (p220) 10.11　需求阶段的CASE工具
2.1.12. (p221) 10.12　需求阶段的度量
2.1.13. (p221) 10.13　面向对象的需求
2.1.14. (p222) 10.14　“空中美食”案例研究：需求阶段
2.1.15. (p224) 10.15　“空中美食”案例研究：快速原型
2.1.16. (p225) 10.16　需求阶段面临的挑战
2.1.17. (p226) 本章回顾
2.1.18. (p227) 进一步阅读指导
2.1.19. (p227) 思考题
2.1.20. (p228) 参考文献
2.2. (p231) 第11章　规格说明阶段
2.2.1. (p231) 11.1　规格说明文档
2.2.2. (p232) 11.2　非形式化规格说明
2.2.3. (p233) 11.3　结构化系统分析
2.2.4. (p239) 11.4　其他半形式化的技术
2.2.5. (p240) 11.5　建造实体－关系模型
2.2.6. (p241) 11.6　有限状态机
2.2.7. (p246) 11.7　Petri网
2.2.8. (p250) 11.8　Z规格说明语言
2.2.9. (p253) 11.9　其他形式化技术
2.2.10. (p253) 11.10　规格说明技术的比较
2.2.11. (p254) 11.11　在规格说明阶段测试
2.2.12. (p255) 11.12　规格说明阶段的CASE工具
2.2.13. (p255) 11.13　规格说明阶段的度量
2.2.14. (p255) 11.14　“空中美食”案例研究：结构化系统分析
2.2.15. (p257) 11.15　“空中美食”案例研究：软件项目管理计划
2.2.16. (p257) 11.16　规格说明阶段面临的挑战
2.2.17. (p258) 本章回顾
2.2.18. (p258) 进一步阅读指导
2.2.19. (p259) 思考题
2.2.20. (p261) 参考文献
2.3. (p265) 第12章　面向对象分析阶段
2.3.1. (p265) 12.1　面向对象分析
2.3.2. (p267) 12.2　电梯问题：面向对象分析
2.3.3. (p267) 12.3　用例建模
2.3.4. (p268) 12.4　类建模
2.3.5. (p271) 12.5　动态建模
2.3.6. (p273) 12.6　在面向对象分析阶段测试
2.3.7. (p276) 12.7　面向对象分析阶段的CASE工具
2.3.8. (p276) 12.8　“空中美食”案例研究：面向对象分析
2.3.9. (p281) 12.9　面向对象分析阶段面临的挑战
2.3.10. (p281) 本章回顾
2.3.11. (p281) 进一步阅读指导
2.3.12. (p282) 思考题
2.3.13. (p283) 参考文献
2.4. (p285) 第13章　设计阶段
2.4.1. (p285) 13.1　设计和抽取
2.4.2. (p286) 13.2　面向行为设计
2.4.3. (p286) 13.3　数据流分析
2.4.4. (p291) 13.4　事务分析
2.4.5. (p292) 13.5　面向数据设计
2.4.6. (p292) 13.6　面向对象设计
2.4.7. (p293) 13.7　电梯问题：面向对象设计
2.4.8. (p299) 13.8　详细设计的形式化技术
2.4.9. (p299) 13.9　实时设计技术
2.4.10. (p300) 13.10　设计期间的测试
2.4.11. (p301) 13.11　设计阶段的CASE工具
2.4.12. (p301) 13.12　设计阶段的度量
2.4.13. (p302) 13.13　“空中美食”案例研究：面向对象设计
2.4.14. (p308) 13.14　设计阶段面临的挑战
2.4.15. (p309) 本章回顾
2.4.16. (p309) 进一步阅读指导
2.4.17. (p309) 思考题
2.4.18. (p310) 参考文献
2.5. (p313) 第14章　实现阶段
2.5.1. (p313) 14.1　编程语言的选择
2.5.2. (p315) 14.2　第四代语言
2.5.3. (p317) 14.3　良好的编程习惯
2.5.4. (p321) 14.4　编码标准
2.5.5. (p322) 14.5　模块复用
2.5.6. (p322) 14.6　模块测试用例选择
2.5.7. (p325) 14.7　黑盒模块测试技术
2.5.8. (p327) 14.8　玻璃盒模块测试技术
2.5.9. (p330) 14.9　代码走查和审查
2.5.10. (p330) 14.10　模块测试技术的比较
2.5.11. (p331) 14.11　净室
2.5.12. (p332) 14.12　测试对象时潜在的问题
2.5.13. (p334) 14.13　模块测试的管理方面
2.5.14. (p334) 14.14　何时该重写而不是调试一个模块
2.5.15. (p335) 14.15　实现阶段的CASE工具
2.5.16. (p335) 14.16　“空中美食”案例研究：黑盒测试用例
2.5.17. (p337) 14.17　实现阶段面临的挑战
2.5.18. (p337) 本章回顾
2.5.19. (p337) 进一步阅读指导
2.5.20. (p338) 思考题
2.5.21. (p339) 参考文献
2.6. (p343) 第15章　实现与集成阶段
2.6.1. (p343) 15.1　实现与集成介绍
2.6.2. (p347) 15.2　实现与集成期间的测试
2.6.3. (p348) 15.3　图形用户界面的集成测试
2.6.4. (p348) 15.4　产品测试
2.6.5. (p349) 15.5　验收测试
2.6.6. (p350) 15.6　实现与集成阶段的CASE工具
2.6.7. (p350) 15.7　软件开发全过程的CASE工具
2.6.8. (p350) 15.8　集成化开发环境
2.6.9. (p351) 15.9　商业应用软件开发环境
2.6.10. (p352) 15.10　公共工具基础结构
2.6.11. (p352) 15.11　开发环境的潜在问题
2.6.12. (p352) 15.12　实现与集成阶段的度量
2.6.13. (p353) 15.13　“空中美食”案例研究：实现与集成阶段
2.6.14. (p353) 15.14　实现与集成阶段面临的挑战
2.6.15. (p353) 本章回顾
2.6.16. (p353) 进一步阅读指导
2.6.17. (p354) 思考题
2.6.18. (p355) 参考文献
2.7. (p357) 第16章　维护阶段
3. (p373) 附录
3.1. (p375) 附录A　Broadlands地区儿童医院
3.2. (p379) 附录B　软件工程资料
3.3. (p381) 附录C　“空中美食”案例研究：C快速原型
3.4. (p382) 附录D　“空中美食”案例研究：Java快速原型
3.5. (p383) 附录E　“空中美食”案例研究：结构化系统分析
3.6. (p389) 附录F　“空中美食”案例研究：软件项目管理计划
3.7. (p393) 附录G　“空中美食”案例研究：面向对象的分析
3.8. (p394) 附录H　“空中美食”案例研究：C++实现的设计
3.9. (p407) 附录I　“空中美食”案例研究：Java实现的设计
3.10. (p419) 附录J　“空中美食”案例研究：黑盒测试用例
3.11. (p424) 附录K　“空中美食”案例研究：C++源代码
3.12. (p425) 附录L　“空中美食”案例研究：Java源代码

全书共分两部分:第一部分介绍了以项目感统基础的软件工程的理论基础; 第二部分讲述了软件生命周期的各个阶段。

2024-06-13