UML基础教程

第1章  UML的基本原理                  
 1. 1  了解软件建模的原因                  
 1. 1. 1  分析. 设计与实现                  
 1. 1. 2  软件生命周期模型                  
 1. 2  理解统一建模过程                  
 1. 2. 1  初始阶段                  
 1. 2. 2  筹划阶段                  
 1. 2. 3  构建阶段                  
 1. 2. 4  转换阶段                  
 1. 3  什么是UML                  
 1. 3. 1  UML的历史                  
 1. 3. 2  OMG                  
 1. 4  认识UML的构件                  
 1. 4. 1  结构图                  
 1. 4. 2  行为图                  
 1. 5  寻找有效的UML建模工具                  
 1. 5. 1  Rational Rose                  
 1. 5. 2  Visio                  
 1. 5. 3  写字板或笔和纸                  
 1. 6  思考与练习                  
 第2章  用例图                  
 2. 1  定义用例图                  
 2. 2  找到用例图建模的原因                  
 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. 5  理解如何使用包含关系和扩展关系                  
 2. 5. 1  包含关系                  
 2. 5. 2  扩展关系                  
 2. 6  学习如何描述用例                  
 2. 7  学习如何建立用例图模型                  
 2. 7. 1  找出参与者和用例                  
 2. 7. 2  区分用例优先次序                  
 2. 7. 3  细化每个用例                  
 2. 7. 4  构建用例模型                  
 2. 8  思考与练习                  
 第3章  面向对象设计介绍                  
 3. 1  认识面向对象设计的特征                  
 3. 2  理解OOD中类的用法                  
 3. 2. 1  抽象                  
 3. 2. 2  封装                  
 3. 2. 3  接口                  
 3. 3  理解OOD中继承的用法                  
 3. 3. 1  继承层次结构                  
 3. 3. 2  多重继承                  
 3. 4  理解OOD中多态性的用法                  
 3. 5  思考与练习                  
 第4章  活动图的工作流建模                  
 4. 1  定义活动图                  
 4. 2  了解为什么建模活动图                  
 4. 3  确定活动图的标记符组件                  
 4. 3. 1  活动：动作状态                  
 4. 3. 2  状态                  
 4. 3. 3  转移                  
 4. 3. 4  综合运用                  
 4. 4  学习如何使用条件                  
 4. 4. 1  控制点                  
 4. 4. 2  决策点                  
 4. 5  学习活动图中的其他标记符                  
 4. 5. 1  事件和触发器                  
 4. 5. 2  游泳道                  
 4. 5. 3  分岔和联结                  
 4. 6  学习如何建模活动图                  
 4. 6. 1  标识用例                  
 4. 6. 2  建模主路径                  
 4. 6. 3  建模从路径                  
 4. 6. 4  添加游泳道                  
 4. 6. 5  改进高层活动                  
 4. 7  思考与练习                  
 第5章  使用顺序图建模行为                  
 5. 1  定义顺序图                  
 5. 2  为什么要建模顺序图                  
 5. 3  了解顺序图的标记符组件                  
 5. 3. 1  活动对象                  
 5. 3. 2  消息                  
 5. 4  理解如何使用消息进行通信                  
 5. 4. 1  同步消息                  
 5. 4. 2  异步消息                  
 5. 4. 3  简单消息                  
 5. 5  学习顺序图使用的其他技术                  
 5. 5. 1  创建对象                  
 5. 5. 2  使用状态                  
 5. 5. 3  分支和从属流                  
 5. 6  学习如何建模顺序图                  
 5. 6. 1  确定工作流                  
 5. 6. 2  布置对象                  
 5. 6. 3  添加消息和条件                  
 5. 6. 4  绘制总图                  
 5. 7  思考与练习                  
 第6章  使用类图定义域模型                  
 6. 1  定义类图                  
 6. 2  为什么要建模类图                  
 6. 3  学习类图的标记符组件                  
 6. 3. 1  类                  
 6. 3. 2  关系                  
 6. 3. 3  多重性                  
 6. 3. 4  角色                  
 6. 4  学习如何建模类                  
 6. 4. 1  特性和操作                  
 6. 4. 2  对象：类实例                  
 6. 4. 3  包                  
 6. 5  学习如何为特性提供信息                  
 6. 5. 1  数据类型                  
 6. 5. 2  初始值                  
 6. 5. 3  多重性                  
 6. 5. 4  派生的特性                  
 6. 6  学习如何为操作提供参数                  
 6. 7  学习如何建模类图                  
 6. 7. 1  确定类和关联                  
 6. 7. 2  确定特性和操作                  
 6. 8  思考与练习                  
 第7章  协作图                  
 7. 1  定义协作图                  
 7. 2  为什么要建模协作图                  
 7. 3  了解协作图的标记符组件                  
 7. 3. 1  对象和角色                  
 7. 3. 2  关联角色                  
 7. 3. 3  链接                  
 7. 3. 4  消息                  
 7. 4  学习不同的消息类型                  
 7. 4. 1  同步消息                  
 7. 4. 2  异步消息                  
 7. 4. 3  简单消息                  
 7. 5  深入研究消息                  
 7. 5. 1  序列化                  
 7. 5. 2  控制点条件                  
 7. 5. 3  创建实例                  
 7. 5. 4  迭代                  
 7. 6  学习如何建模协作图                  
 7. 6. 1  确定协作图的元素                  
 7. 6. 2  建模结构化关系                  
 7. 6. 3  建模实例层协作图                  
 7. 7  思考与练习                  
 第8章  深入学习类图                  
 8. 1  学习聚集和组成                  
 8. 1. 1  聚集                  
 8. 1. 2  组成                  
 8. 1. 3  使用带有泛化的聚集和组成                  
 8. 2  学习关联注释                  
 8. 2. 1  约束                  
 8. 2. 2  鉴别器                  
 8. 3  学习端点标记符                  
 8. 3. 1  有序和排序                  
 8. 3. 2  导航                  
 8. 4  建模多个关联                  
 8. 5  思考与练习                  
 第9章  深入学习顺序图                  
 9. 1  学习控制矩形                  
 9. 1. 1  使用控制矩形                  
 9. 1. 2  指定活动期间                  
 9. 2  学习如何建模时间                  
 9. 2. 1  指示时间上的变化                  
 9. 2. 2  建模时间约束                  
 9. 2. 3  建模持续时间                  
 9. 3  学习如何建模迭代                  
 9. 3. 1  建模循环                  
 9. 3. 2  建模递归                  
 9. 4  学习如何建模高级消息                  
 9. 4. 1  消息参数和返回值                  
 9. 4. 2  指定消息序列                  
 9. 5  学习如何向顺序图中添加注释                  
 9. 6  思考与练习                  
 第10章  使用状态图建模行为                  
 10. 1  定义状态图                  
 10. 2  为什么要建模状态图                  
 10. 3  学习状态图的标记符组件                  
 10. 3. 1  状态                  
 10. 3. 2  转移                  
 10. 3. 3  决策点                  
 10. 3. 4  同步                  
 10. 4  学习如何指定状态的动作和事件                  
 10. 4. 1  事件                  
 10. 4. 2  动作                  
 10. 5  学习如何使用合成状态                  
 10. 5. 1  子状态                  
 10. 5. 2  合成状态                  
 10. 6  学习如何建模状态图                  
 10. 6. 1  标识出需要进一步建模的实体                  
 10. 6. 2  标识出每一个实体的开始状态和结束状态                  
 10. 6. 3  确定与每一个实体相关的事件                  
 10. 6. 4  从开始状态开始创建状态图                  
 10. 6. 5  如果必要则指定合成状态                  
 10. 7  思考与练习                  
 第11章  构造实现方式图                  
 11. 1  定义实现方式图                  
 11. 2  了解为什么要建模实现方式图                  
 11. 3  学习组件图                  
 11. 3. 1  组件                  
 11. 3. 2  依赖关系                  
 11. 3. 3  固化依赖关系                  
 11. 3. 4  包含组件                  
 11. 4  学习部署图                  
 11. 4. 1  节点                  
 11. 4. 2  通信关联                  
 11. 4. 3  组合组件图和部署图                  
 11. 5  学习如何建模实现方式图                  
 11. 5. 1  添加节点                  
 11. 5. 2  添加通信关联                  
 11. 5. 3  添加组件. 类和对象                  
 11. 5. 4  添加依赖关系                  
 11. 6  思考与练习                  
 第12章  使用对象约束语言                  
 12. 1  定义对象约束语言                  
 12. 2  为什么使用对象约束语言                  
 12. 3  学习OCL语法                  
 12. 3. 1  上下文和固化类型                  
 12. 3. 2  类型和操作                  
 12. 4  学习集合的用法                  
 12. 4. 1  集                  
 12. 4. 2  序列                  
 12. 4. 3  袋子                  
 12. 4. 4  其他集合常用的操作                  
 12. 5  思考与练习                  
 附录A  思考与练习答案                  
 附录B  术语表