UML应用建模实践过程

第一部分  基本理念和准备知识                  
 第1章  分析和设计的逻辑模型                  
 1. 1  模型在认知和求解中的价值                  
 1. 2  分析和设计的对立. 关联和统一                  
 1. 3  分析和设计的逻辑模型                  
 第2章  面向对象的内涵. 优势和原则                  
 2. 1  方法. 技术和工具的综合                  
 2. 2  改善沟通. 复用与应变能力                  
 2. 3  抽象. 封装与层次                  
 第3章  模型内容的组织和UML表述                  
 3. 1  模型的基本组织结构                  
 3. 1. 1  基本内容                  
 3. 1. 2  语义扩展                  
 3. 1. 3  组织方式                  
 3. 2  常见图的用法与内容                  
 3. 2. 1  Use Case图：描述拟建系统与外部环境的关系                  
 3. 2. 2  Use Case图：描述需求模型与设计模型的关系                  
 3. 2. 3  类图：描述类. 接口和子系统之间的关系                  
 3. 2. 4  类图：描述包之间的依赖关系                  
 3. 2. 5  序列图：描述局部分析和设计的场景                  
 3. 2. 6  序列图：描述"构架机制"的典型场景                  
 3. 2. 7  协作图：描述局部分析和设计的场景                  
 3. 2. 8  状态图：描述具有明显状态特征的类                  
 3. 2. 9  活动图：描述Use Case的事件流结构                  
 第二部分  UML应用建模实践过程                  
 第4章  应用建模实践过程概述                  
 4. 1  任务和活动                  
 4. 2  角色和分工                  
 4. 3  设计模型的内容和演进                  
 4. 4  示例软件需求说明                  
 第5章  全局分析                  
 5. 1  选用构架模式                  
 5. 1. 1  概念：构架的沿用                  
 5. 1. 2  步骤1：选用构架模式                  
 5. 1. 3  步骤2：定义构架的应用逻辑相关部分                  
 5. 1. 4  技巧：划分层次的经验规则                  
 5. 1. 5  技巧：层次内分区的出发点                  
 5. 1. 6  示例                  
 5. 2  识别"关键抽象"                  
 5. 2. 1  概念："关键抽象"的含义                  
 5. 2. 2  概念："关键抽象"的沿用                  
 5. 2. 3  步骤1：搜集"关键抽象"的来源                  
 5. 2. 4  步骡2：识别"关键抽象"                  
 5. 2. 5  技巧："关键抽象"包的价值                  
 5. 2. 6  技巧：利用业务模型                  
 5. 2. 7  技巧：利用成熟的领域经验                  
 5. 2. 8  示例                  
 5. 3  标识"分析机制"                  
 5. 3. 1  概念："分析机制"的含义                  
 5. 3. 2  概念：常见的"分析机制"                  
 5. 3. 3  概念："分析机制"的沿用                  
 5. 3. 4  步骤1：确定"分析机制"                  
 5. 3. 5  步骤2：简述"分析机制"                  
 5. 3. 6  技巧：确定"分析机制"的方式                  
 5. 3. 7  技巧：抽取自己的成功经验                  
 5. 3. 8  技巧：利用他人的成功经验                  
 5. 3. 9  示例                  
 5. 4  选定分析局部                  
 5. 4. 1  概念："Use Case实现"的桥梁作用                  
 5. 4. 2  概念：风险前驱的迭代化开发策略                  
 5. 4. 3  步骤1：选定当前的待分析局部                  
 5. 4. 4  步骤2：建立"Use Case实现"框架                  
 5. 4. 5  技巧：既往经验的价值                  
 5. 4. 6  技巧：复杂的未必重要                  
 5. 4. 7  技巧：借鉴80-20规则                  
 5. 4. 8  示例                  
 第6章  局部分析                  
 6. 1  提取"分析类"                  
 6. 1. 1  概念："分析类"的含义                  
 6. 1. 2  概念："分析类"的类型划分                  
 6. 1. 3  概念：边界类的含义                  
 6. 1. 4  概念：控制类的含义                  
 6. 1. 5  概念：实体类的含义                  
 6. 1. 6  概念："分析类"的沿用                  
 6. 1. 7  步骤1：充实Use Case内容                  
 6. 1. 8  步骤2：提取"分析类"                  
 6. 1. 9  技巧："分析类"在模型中的位置                  
 6. 1. 10  技巧：边界类的复用                  
 6. 1. 11  技巧：控制类的变通                  
 6. 1. 12  技巧：实体类的建议                  
 6. 1. 13  技巧：构造型的可选性                  
 6. 1. 14  示例                  
 6. 2  转述需求场景                  
 6. 2. 1  概念："消息"与"责任"                  
 6. 2. 2  概念："责任"的沿用                  
 6. 2. 3  概念：序列图中的Actor实例                  
 6. 2. 4  步骤1：描述Use Case事件序列                  
 6. 2. 5  步骤2：找出对象传递"消息"的通道                  
 6. 2. 6  技巧："未被指派的消息"                  
 6. 2. 7  技巧：控制类在交互图中的表现特征                  
 6. 2. 8  技巧：省略序列图中被动Act叮的实例                  
 6. 2. 9  技巧："返回消息"                  
 6. 2. 10  技巧：在序列图中作文字注释                  
 6. 2. 11  技巧：根据需要建立协作图                  
 6. 2. 12  技巧：交互图的正确性                  
 6. 2. 13  示例                  
 6. 3  整理分析类                  
 6. 3. 1  概念："分析类"的"责任"和关联关系                  
 6. 3. 2  概念：动态与静态的关系                  
 6. 3. 3  概念："分析类"的属性                  
 6. 3. 4  概念："参与类图"的含义                  
 6. 3. 5  步骤1：确定"分析类"的"责任"                  
 6. 3. 6  步骤2：确定"分析类"间的关联关系                  
 6. 3. 7  步骤3：确定"分析类"的属性                  
 6. 3. 8  技巧：实体类与属性的差异                  
 6. 3. 9  技巧：不同"分析类"的同名"责任"                  
 6. 3. 10  技巧：复用已有的"责任". 属性和关联关系                  
 6. 3. 11  示例                  
 第7章  全局设计                  
 7. 1  确定核心元素                  
 7. 1. 1  概念："核心设计元素"的含义                  
 7. 1. 2  概念："子系统接口"的定义                  
 7. 1. 3  步骤1：映射"分析类"到"设计元素"                  
 7. 1. 4  步骤2：定义"子系统接口"                  
 7. 1. 5  技巧："子系统接口"的动态表述                  
 7. 1. 6  技巧："子系统接口"的辅助说明                  
 7. 1. 7  技巧："子系统接口"的融合                  
 7. 1. 8  技巧："子系统接口"定义的调整                  
 7. 1. 9  技巧："子系统接口"在模型中的位置                  
 7. 1. 10  技巧：推迟明确"设计类"的操作                  
 7. 1. 11  示例                  
 7. 2  引入外围元素                  
 7. 2. 1  概念："设计机制"与"实施机制"                  
 7. 2. 2  概念："外围设计元素"的含义                  
 7. 2. 3  步骤1："分析机制"向"设计机制"映射                  
 7. 2. 4  步骤2：落实"设计机制"的具体内容                  
 7. 2. 5  技巧："设计机制"的分组                  
 7. 2. 6  技巧："实施机制"的综合考虑                  
 7. 2. 7  示例                  
 7. 3  优化组织结构                  
 7. 3. 1  概念：层次构架内容的复用价值                  
 7. 3. 2  概念：层次构架中积累的内容                  
 7. 3. 3  概念：包之间的依赖关系                  
 7. 3. 4  步骤1：分包组织"设计元素"                  
 7. 3. 5  步骤2：描述包之间的依赖关系                  
 7. 3. 6  技巧：利用层次内的分区信息                  
 7. 3. 7  技巧：判别"紧密相关"的类                  
 7. 3. 8  技巧：针对"不易分拆"的包                  
 7. 3. 9  技巧：弱化包之间的精合关系                  
 7. 3. 10  技巧："包的事实接口"                  
 7. 3. 11  示例                  
 第8章  局部设计                  
 8. 1  实现需求场景                  
 8. 1. 1  概念："分析类"和"设计元素"的差异                  
 8. 1. 2  步骤1：用"核心设计元素"替换"分析类"                  
 8. 1. 3  步骤2：落实"构架机制"的支撑作用                  
 8. 1. 4  技巧：为"责任"提供上下文信息                  
 8. 1. 5  示例                  
 8. 2  实现子系统接口                  
 8. 2. 1  概念："小型的Use Case"                  
 8. 2. 2  步骤1：实现"子系统接口"定义的行为                  
 8. 2. 3  步骤2：明确子系统与其外部设计元素的关系                  
 8. 2. 4  技巧：提前实现"子系统接口"                  
 8. 2. 5  技巧：确保子系统的独立性                  
 8. 2. 6  技巧：不同子系统之间的依赖关系                  
 8. 2. 7  示例                  
 第9章  细节设计                  
 9. 1  精化属性和操作                  
 9. 1. 1  概念：需要精化的类                  
 9. 1. 2  概念：操作(opention)                  
 9. 1. 3  概念：属性(Atribute)                  
 9. 1. 4  概念：操作和属性的可见度(Visibility)                  
 9. 1. 5  概念：类的可见度                  
 9. 1. 6  概念：操作和属性的适用范围(Scope)                  
 9. 1. 7  步骤1：明确操作的定义                  
 9. 1. 8  步骤2：明确属性的定义                  
 9. 1. 9  技巧：应用状态图获得操作和属性                  
 9. 1. 10  技巧"导出属性"的使用价值                  
 9. 1. 11  技巧：操作命名的注意事项                  
 9. 1. 12  技巧：说明操作的实现逻辑                  
 9. 1. 13  技巧：可见度的判断                  
 9. 1. 14  示例                  
 9. 2  明确类之间关系                  
 9. 2. 1  概念：对象间通信的"连接可见度"(Link Visibility)                  
 9. 2. 2  概念：关联关系的细节内容                  
 9. 2. 3  概念：分解(Factoring)和委托(Delegation)                  
 9. 2. 4  步骤1：明确依赖关系                  
 9. 2. 5  步骤2：细化关联关系                  
 9. 2. 6  步骤3：构造泛化关系                  
 9. 2. 7  技巧：定义"关联类"(Association Class)                  
 9. 2. 8  技巧：定义"嵌入类"(Nested Class)                  
 9. 2. 9  技巧：用组合关系分拆"胖"类                  
 9. 2. 10  技巧：引入适用的设计模式                  
 9. 2. 11  示例                  
 第三部分  设计模型的沿用                  
 第10章  设计模型向实施模型的过渡                  
 10. 1  实施模型的基本概念                  
 10. 1. 1  实施模型                  
 10. 1. 2  构件                  
 10. 1. 3  "实施子系统"                  
 10. 1. 4  构件图                  
 10. 2  设计模型向实施模型的过渡                  
 10. 2. 1  明确实施模型的依据                  
 10. 2. 2  建立实施模型的框架                  
 10. 2. 3  实现设计模型的内容                  
 第11章  设计模型和数据模型的关联                  
 11. 1  数据模型的基本概念                  
 11. 1. 1  数据模型                  
 11. 1. 2  实体和关系                  
 11. 1. 3  存储过程                  
 11. 2  设计模型和数据模型的映射                  
 11. 2. 1  面向对象和关系型数据的差异                  
 11. 2. 2  映射"实体"                  
 11. 2. 3  映射"关系"                  
 11. 2. 4  映射围绕数据的行为                  
 11. 2. 5  优化性能的考虑                  
 第12章  整理设计文档                  
 12. 1  分析和设计活动中的主要文档                  
 12. 2  设计指南                  
 12. 3  "Use Case实现"报告                  
 12. 4  设计模型纵览报告                  
 12. 5  设计包报告                  
 12. 6  设计类报告                  
 附录                  
 附录A  应用建模实践过程中的术语                  
 附录B  应用建模实践过程中的快速参考图述                  
 附录C  UML用于数据建模元素构造型                  
 参考文献