面向对象的设计（32#）

引言                  
 0. 1　历史                  
 0. 2　方法和工具                  
 0. 3　未来的工作                  
 第一章　改进设计                  
 1. 1　基本术语                  
 1. 2　控制复杂性的原则                  
 1. 2. 1　抽象                  
 1. 2. 2　封装                  
 1. 2. 3　继承性（刻画一般性－特殊性）                  
 1. 2. 4　联系                  
 1. 2. 5　消息通信                  
 1. 2. 6　通用的组织法则                  
 1. 2. 7　粒度                  
 1. 2. 8　行为分类                  
 1. 3　OOD和原型的影响                  
 1. 3. 1　做原型的因由                  
 1. 3. 2　关于OOD原型的忠告                  
 1. 4　OOD的根本目标                  
 1. 4. 1　增进生产效率                  
 1. 4. 2　提高质量                  
 1. 4. 3　加强可维护性                  
 1. 5　OOD的动机和益处                  
 第二章　开发多层次. 多部分任务的模型                  
 2. 1　模型是怎样发现的                  
 2. 2　表示法的统一                  
 2. 2. 1　问题                  
 2. 2. 2　一种解决方法                  
 2. 2. 3　几个重要含意                  
 2. 3　五个层次. 五个活动                  
 2. 4　四个部分. 四个活动                  
 2. 5　定义和表示法                  
 2. 5. 1　定义和表示法--类及对象                  
 2. 5. 2　定义和表示法--结构                  
 2. 5. 3　定义和表示法--主题                  
 2. 5. 4　定义和表示法--属性（及实例连接）                  
 2. 5. 5　定义和表示法-一服务（及消息连接）                  
 2. 5. 6　表示法--概括                  
 第三章　问题域部分的设计                  
 3. 1　什么是问题域部分                  
 3. 1. 1　方法--不是什么                  
 3. 1. 2　方法--是什么                  
 3. 2　为什么需要问题域部分的设计                  
 3. 3　如何进行问题域部分的设计                  
 3. 3. 1  运用OOA                  
 3. 3. 2　使用OOA结果--并在OOD期间加以改进                  
 3. 3. 3　运用OOA结果--并在OOD期间加以增补                  
 3. 3. 4　例子--传感器监控系统                  
 3. 3. 5　例子--OOAToolTM                  
 第四章　人机交互部分的设计                  
 4. 1　什么是人机交互部分                  
 4. 2　为什么需要人机交互部分                  
 4. 3　如何设计人机交互部分                  
 4. 3. 1　对人分类                  
 4. 3. 2　描述人及其任务脚本                  
 4. 3. 3　设计命令层                  
 4. 3. 4　设计详细的交互                  
 4. 3. 5　继续做原型                  
 4. 3. 6　设计HIC类                  
 4. 3. 7　根据图形用户界面进行设计                  
 4. 3. 8　例子--传感器监控系统                  
 4. 3. 9　例子--OOAToolTM                  
 第五章  任务管理部分的设计                  
 5. 1　什么是任务管理部分                  
 5. 2　为什么需要有任务管理部分                  
 5. 3　怎样设计任务管理部分                  
 5. 3. 1　识别事件驱动任务                  
 5. 3. 2　识别时钟驱动任务                  
 5. 3. 3　识别优先任务和关键任务                  
 5. 3. 4　识别协调者                  
 5. 3. 5　审查每个任务                  
 5. 3. 6　定义每个任务                  
 5. 3. 7　例子--传感器监控系统                  
 5. 3. 8　例子--OOAToolTM                  
 第六章　截据管理部分的设计                  
 6. 1　什么是数据管理部分                  
 6. 2　为什么需要数据管理部分                  
 6. 3　如何设计数据管理部分                  
 6. 3. 1　数据管理方法                  
 6. 3. 2　对数据管理工具的评价                  
 6. 3. 3　数据管理部分的设计                  
 6. 3. 4　例子--传感器监控系统                  
 6. 3. 5　例子--OOAToolTM                  
 第七章　通过OOPL（或者非OO语言）应用OOD                  
 7. 1　对语言, 一切从实际出发                  
 7. 2　语言对OO开发的影响                  
 7. 3　评价语言的语法和特征                  
 7. 3. 1　评价标准                  
 7. 3. 2　语法与特征--C＋＋和ObjectPascal                  
 7. 3. 3　语法与特征--Smalltalk和Objective－C                  
 7. 3. 4　语法与特征--Eiffel                  
 7. 3. 5　语法与特征--Ada, 一种面向程序包的语言                  
 7. 3. 6　语法与特征--过程语言                  
 7. 4　选择OOPL                  
 7. 4. 1　哪个OOPL将占有支配地位？                  
 7. 4. 2　从OOA到OOD到OOPL的可重用性                  
 7. 4. 3　类库和开发环境                  
 7. 4. 4　其它问题                  
 第八章　采用OOD评价标准                  
 8. 1　导言：什么是OOD评价标准, 为什么要采用OOD评价标准                  
 8. 2　耦合                  
 8. 2. 1　交互耦合                  
 8. 2. 2　继承耦合                  
 8. 3　内聚                  
 8. 3. 1　服务内聚                  
 8. 3. 2　类内聚                  
 8. 3. 3　一般－特殊内聚                  
 8. 4　重用                  
 8. 4. 1　重用为什么很重要？                  
 8. 4. 2　做不到重用的原因何在？                  
 8. 4. 3　重用的级别                  
 8. 4. 4　可重用性的组织方法                  
 8. 5　其它评价标准                  
 8. 5. 1　设计的清晰度                  
 8. 5. 2　一般－特殊结构的深度                  
 8. 5. 3　保持对象和类的简单性                  
 8. 5. 4　保持协议的简单性                  
 8. 5. 5　保持服务的简单性                  
 8. 5. 6　把设计易变性最小化                  
 8. 5. 7　系统总体规模最小化                  
 8. 5. 8　能够用"脚本"评估                  
 8. 5. 9　通过"关键成功因素"来评估                  
 8. 5. 10　设计中公认的优雅风格                  
 8. 6　小结                  
 第九章　为OOD选择CASE                  
 9. 1　扩充CASE                  
 9. 2　OOD需要什么                  
 9. 2. 1　表示法                  
 9. 2. 2　层次                  
 9. 2. 3　组成部分                  
 9. 2. 4　自动跟踪特性                  
 9. 2. 5　高级特性                  
 9. 2. 6　模型检查                  
 9. 3　目前已有哪些可用的CASE工具                  
 9. 4　进一步的考虑                  
 第十章　开始OOD                  
 10. 1　另一个银弹？                  
 10. 2　是开始用OOD的时候了吗？                  
 10. 2. 1　面向对象的范型成熟了吗？                  
 10. 2. 2　有没有好的面向对象实现技术？                  
 10. 2. 3　开发组织是否足够老练？                  
 10. 2. 4　该组织建造的系统是否将采用面向对象的技术？                  
 10. 3　革命与演化                  
 10. 4　如何开始OOD                  
 10. 5　结束语                  
 附录A                  
 附录B                  
 附录C