面向对象的分析与设计

第一部分  什么是面向对象                  
 第1章  面向对象简介                  
 1. 1  结构化技术和面向对象技术的比较                  
 1. 2  什么是面向对象                  
 1. 2. 1  面向对象技术是如何与用户关联的                  
 1. 2. 2  面向对象技术的其他优势                  
 1. 2. 3  面向对象技术的一些弱势                  
 1. 3  什么是对象                  
 1. 3. 1  识别对象                  
 1. 3. 2  属性                  
 1. 3. 3  方法                  
 1. 3. 4  对象状态                  
 1. 3. 5  类                  
 1. 4  面向对象基础                  
 1. 5  继承                  
 1. 6  重定义                  
 1. 7  文档                  
 1. 7. 1  类的描述                  
 1. 7. 2  图的使用                  
 1. 7. 3  继承                  
 1. 7. 4  编码规范                  
 1. 8  小结                  
 第二部分分  析                  
 第2章  分析                  
 2. 1  预分析                  
 2. 2  当一个对象不成为对象时                  
 2. 2. 1  公共汽车站问题域的实例                  
 2. 2. 2  桌子问题域的实例                  
 2. 2. 3  问题域小结                  
 2. 3  使用用例分析                  
 2. 3. 1  用例图                  
 2. 3. 2  一个简单用例的例子                  
 2. 3. 3  一个用例模板                  
 2. 3. 4  一个用例实例                  
 2. 3. 5  写好用例的七个要点                  
 2. 4  记录分析                  
 2. 4. 1  分析文档：类的静态特性                  
 2. 4. 2  分析文档：类的动态特性                  
 2. 4. 3  分析文档：系统的静态特性                  
 2. 4. 4  分析文档：系统的动态特性                  
 2. 5  小结                  
 第三部分设  计                  
 第3章  设计方案                  
 3. 1  抽象类                  
 3. 2  应用程序编程接口                  
 3. 2. 1  API结构出现以前                  
 3. 2. 2  为什么使用API结构                  
 3. 2. 3  从API类中派生                  
 3. 2. 4  使用API类                  
 3. 2. 5  Java原始接口                  
 3. 3  模板                  
 3. 3. 1  何时使用模板而不使用继承                  
 3. 3. 2  在C++中实现的模板样本                  
 3. 4  好的设计--原则和度量标准                  
 3. 4. 1  认识设计中"毒瘤"产生的原因                  
 3. 4. 2  面向对象的类的设计原则                  
 3. 4. 3  设计的度量标准                  
 3. 5  全局对象                  
 3. 6  确定实现方法                  
 3. 7  虚方法                  
 3. 8  复制构造函数                  
 3. 8. 1  表层复制构造函数                  
 3. 8. 2  深层复制构造函数                  
 3. 9  关联的实现                  
 3. 9. 1  双向关联                  
 3. 9. 2  单向关联                  
 3. 10  小结                  
 第4章  需要避免的设计方案                  
 4. 1  过程对象                  
 4. 1. 1  过程的变化                  
 4. 1. 2  差异处理                  
 4. 1. 3  增加新的订单类型                  
 4. 1. 4  将控制过程放在对象内部                  
 4. 2  责任的委托                  
 4. 2. 1  实例1--确定某人的年龄                  
 4. 2. 2  实例2--过滤数据                  
 4. 3  方法责任                  
 4. 3. 1  实例1--买一台烤面包炉                  
 4. 3. 2  实例2--显示运动队的信息                  
 4. 3. 3  实例3--更新联盟中各运动队列表                  
 4. 3. 4  实例4--对联盟中各运动队排序                  
 4. 3. 5  方法的回顾                  
 4. 4  C++中的友元结构                  
 4. 4. 1  访问级别                  
 4. 4. 2  友元是如何影响访问级别的                  
 4. 4. 3  使用友元结构                  
 4. 4. 4  对友元结构的评价                  
 4. 5  多重继承                  
 4. 5. 1  从WorkingStudent派生一个类                  
 4. 5. 2  重新定义被继承的name方法                  
 4. 5. 3  多重继承菱形                  
 4. 5. 4  多重继承的替代方法                  
 4. 6  继承的不当使用                  
 4. 7  小结                  
 第5章  高级设计技术                  
 5. 1  高级朋结构                  
 5. 1. 1  什么是高级API结构                  
 5. 1. 2  如何克服缺点                  
 5. 2  线程                  
 5. 2. 1  资源同步                  
 5. 2. 2  Java同步的问题                  
 5. 2. 3  资源的死锁                  
 5. 3  Model/View/Controller机制                  
 5. 3. 1  中心MVC Controller方案                  
 5. 3. 2  线程方案                  
 5. 3. 3  被动反应式方案                  
 5. 3. 4  Java方案                  
 5. 4  暴露接口方案                  
 5. 5  引用计数                  
 5. 5. 1  通过继承实现引用计数                  
 5. 5. 2  通过关联实现引用计数                  
 5. 5. 3  多线程应用程序                  
 5. 6  小结                  
 第四部分  编  程                  
 第6章  测试                  
 6. 1  测试装备                  
 6. 2  关于构造方法和析构方法的测试                  
 6. 3  方法测试                  
 6. 3. 1  if-then-else                  
 6. 3. 2  for循环                  
 6. 3. 3  while循环                  
 6. 3. 4  switch语句                  
 6. 3. 5  try-catch                  
 6. 3. 6  函数调用                  
 6. 3. 7  测试单个方法的例子                  
 6. 4  类测试                  
 6. 5  整体测试                  
 6. 6  图形用户界面测试                  
 6. 6. 1  基本窗口测试                  
 6. 6. 2  使用菜单                  
 6. 7  强度测试                  
 6. 8  系统测试                  
 6. 9  规模测试                  
 6. 10  回归测试                  
 6. 11  小结                  
 第7章  调试                  
 7. 1  使用调试工具前的准备                  
 7. 2  启动调试工具                  
 7. 2. 1  首先启动调试工具                  
 7. 2. 2  将调试工具联上运行中的应用程序                  
 7. 2. 3  使用调试工具和核心文件                  
 7. 3  调试工具的子命令                  
 7. 3. 1  使应用程序停止                  
 7. 3. 2  运行应用程序                  
 7. 3. 3  检查应用程序                  
 7. 3. 4  检查数据                  
 7. 3. 5  确定逐行控制                  
 7. 3. 6  检查多线程应用程序                  
 7. 3. 7  别名                  
 7. 4  调试实例                  
 7. 4. 1  实例代码                  
 7. 4. 2  使用调试工具                  
 7. 5  小结                  
 第8章  移植                  
 8. 1  移植到新的操作系统                  
 8. 1. 1  Microsoft Visual C++中的线程支持                  
 8. 1. 2  UNIX中的线程支持                  
 8. 1. 3  Java中的线程支持                  
 8. 2  移植到新的硬件平台                  
 8. 2. 1  支持Endianism                  
 8. 2. 2  32位和64位机器的比较                  
 8. 3  移植到新的语言                  
 8. 3. 1  国际化和本地化                  
 8. 3. 2  应用程序国际化时需要考虑的问题                  
 8. 3. 3  单字节和双字节字符集                  
 8. 3. 4  宽字符串                  
 8. 3. 5  Unicode                  
 8. 4  将消息中的字符串本地化                  
 8. 4. 1  创建消息目录--UNIX                  
 8. 4. 2  资源文件--Microsoft                  
 8. 5  开发国际化应用程序                  
 8. 5. 1  策划一个国际化应用程序                  
 8. 5. 2  确定接受哪些数据                  
 8. 5. 3  编写代码                  
 8. 5. 4  设计用户界面                  
 8. 5. 5  测试应用程序                  
 8. 6  设计用户界面                  
 8. 6. 1  创建应用程序消息文本                  
 8. 6. 2  设计菜单和表单                  
 8. 6. 3  使用图标和位图                  
 8. 7  建立可被移植的应用程序的目标结构                  
 8. 8  小结                  
 第9章  应用程序生命周期                  
 9. 1  写出源代码的文档                  
 9. 1. 1  一般的注释                  
 9. 1. 2  C++文件的文档                  
 9. 1. 3  C++头文件的语法                  
 9. 1. 4  Java文件的文档                  
 9. 1. 5  源代码语句的安排                  
 9. 2  组织项目的目录结构                  
 9. 3  使用make工具                  
 9. 3. 1  选项                  
 9. 3. 2  操作数                  
 9. 3. 3  读取makefile和环境                  
 9. 3. 4  makefile目标项                  
 9. 3. 5  特殊字符                  
 9. 3. 6  特殊功能目标                  
 9. 3. 7  后缀替换宏引用                  
 9. 3. 8  makefile的例子                  
 9. 3. 9  可移植makefile的例子                  
 9. 3. 10  创建依赖条件                  
 9. 4  使用源代码管理控制工具                  
 9. 4. 1  源代码管理控制系统                  
 9. 4. 2  SCCS的例子                  
 9. 5  错误报告                  
 9. 6  改进需求                  
 9. 7  修改记录                  
 9. 8  回归测试                  
 9. 9  小结                  
 第五部分  实例学习                  
 第10章  实例学习1--一个模拟的公司                  
 10. 1  项目需求                  
 10. 2  用例                  
 10. 2. 1  用例模板的翻版                  
 10. 2. 2  Use Case #1--贷款申请                  
 10. 2. 3  Use Case #2--购置机器设备                  
 10. 2. 4  Use Case #3--生产运营                  
 10. 2. 5  Use Case #4--处理公司的账务                  
 10. 2. 6  Use Case #5--显示公司的详细信息                  
 10. 3  分析文档--类的静态特性                  
 10. 3. 1  类图                  
 10. 3. 2  CRC卡片                  
 10. 3. 3  脚本                  
 10. 4  分析文档--类的动态特性                  
 10. 5  分析文档--系统的静态特性                  
 10. 5. 1  类关系图                  
 10. 5. 2  协作图                  
 10. 6  分析文档--系统的动态特性                  
 10. 6. 1  活动图                  
 10. 6. 2  序列脚本                  
 10. 6. 3  序列图                  
 10. 7  小结                  
 第11章  实例学习2--开发一个多线程机场管理模拟程序                  
 11. 1  一次只有一架飞机                  
 11. 2  一个停机位人口同时有两架飞机                  
 11. 2. 1  降落过程                  
 11. 2. 2  起飞过程                  
 11. 2. 3  修改后的降落／起飞过程                  
 11. 2. 4  修改后的Java代码                  
 11. 3  一个停机位入口同时有三架飞机                  
 11. 3. 1  降落过程                  
 11. 3. 2  起飞过程                  
 11. 3. 3  修改后的降落过程                  
 11. 3. 4  修改后的Java代码                  
 11. 4  更多的飞机--再增加一些停机位人口                  
 11. 5  飞机在机场活动的整个生存周期                  
 11. 6  最终的解决方案                  
 11. 6. 1  机场细节信息窗口                  
 11. 6. 2  Java代码                  
 11. 7  小结                  
 附录  "哲学家"源代码