Table of Contents | Learning UML 2.0

Learning UML 2.0
By Kim Hamilton, Russell Miles
...............................................
Publisher: O'Reilly
Pub Date: April 2006
Print ISBN-10: 0-596-00982-8
Print ISBN-13: 978-0-59-600982-3
Pages: 286

Table of Contents | Index

Preface

Chapter 1. Introduction

Section 1.1. What's in a Modeling Language?

Section 1.2. Why UML 2.0?

Section 1.3. Models and Diagrams

Section 1.4. "Degrees" of UML

Section 1.5. UML and the Software Development Process

Section 1.6. Views of Your Model

Section 1.7. A First Taste of UML

Section 1.8. Want More Information?

Chapter 2. Modeling Requirements: Use Cases

Section 2.1. Capturing a System Requirement

Section 2.2. Use Case Relationships

Section 2.3. Use Case Overview Diagrams

Section 2.4. What's Next?

Chapter 3. Modeling System Workflows: Activity Diagrams

Section 3.1. Activity Diagram Essentials

Section 3.2. Activities and Actions

Section 3.3. Decisions and Merges

Section 3.4. Doing Multiple Tasks at the Same Time

Section 3.5. Time Events

Section 3.6. Calling Other Activities

Section 3.7. Objects

Section 3.8. Sending and Receiving Signals

Section 3.9. Starting an Activity

Section 3.10. Ending Activities and Flows

Section 3.11. Partitions (or Swimlanes)

Section 3.12. Managing Complex Activity Diagrams

Section 3.13. What's Next?

Chapter 4. Modeling a System's Logical Structure: Introducing Classes and Class Diagrams

Section 4.1. What Is a Class?

Section 4.2. Getting Started with Classes in UML

Section 4.3. Visibility

Section 4.4. Class State: Attributes

Section 4.5. Class Behavior: Operations

Section 4.6. Static Parts of Your Classes

Section 4.7. What's Next

Chapter 5. Modeling a System's Logical Structure: Advanced Class Diagrams

Section 5.1. Class Relationships

Section 5.2. Constraints

Section 5.3. Abstract Classes

Section 5.4. Interfaces

Section 5.5. Templates

Section 5.6. What's Next

Chapter 6. Bringing Your Classes to Life: Object Diagrams

Section 6.1. Object Instances

Section 6.2. Links

Section 6.3. Binding Class Templates

Section 6.4. What's Next?

Chapter 7. Modeling Ordered Interactions: Sequence Diagrams

Section 7.1. Participants in a Sequence Diagram

Section 7.2. Time

Section 7.3. Events, Signals, and Messages

Section 7.4. Activation Bars

Section 7.5. Nested Messages

Section 7.6. Message Arrows

Section 7.7. Bringing a Use Case to Life with a Sequence Diagram

Section 7.8. Managing Complex Interactions with Sequence Fragments

Section 7.9. What's Next?

Chapter 8. Focusing on Interaction Links: Communication Diagrams

Section 8.1. Participants, Links, and Messages

Section 8.2. Fleshing out an Interaction with a Communication Diagram

Section 8.3. Communication Diagrams Versus Sequence Diagrams

Section 8.4. What's Next?

Chapter 9. Focusing on Interaction Timing: Timing Diagrams

Section 9.1. What Do Timing Diagrams Look Like?

Section 9.2. Building a Timing Diagram from a Sequence Diagram

Section 9.3. Applying Participants to a Timing Diagram

Section 9.4. States

Section 9.5. Time

Section 9.6. A Participant's State-Line

Section 9.7. Events and Messages

Section 9.8. Timing Constraints

Section 9.9. Organizing Participants on a Timing Diagram

Section 9.10. An Alternate Notation

Section 9.11. What's Next?

Chapter 10. Completing the Interaction Picture: Interaction Overview Diagrams

Section 10.1. The Parts of an Interaction Overview Diagram

Section 10.2. Modeling a Use Case Using an Interaction Overview

Section 10.3. What's Next?

Chapter 11. Modeling a Class's Internal Structure: Composite Structures

Section 11.1. Internal Structure

Section 11.2. Showing How a Class Is Used

Section 11.3. Showing Patterns with Collaborations

Section 11.4. What's Next?

Chapter 12. Managing and Reusing Your System's Parts: Component Diagrams

Section 12.1. What Is a Component?

Section 12.2. A Basic Component in UML

Section 12.3. Provided and Required Interfaces of a Component

Section 12.4. Showing Components Working Together

Section 12.5. Classes That Realize a Component

Section 12.6. Ports and Internal Structure

Section 12.7. Black-Box and White-Box Component Views

Section 12.8. What's Next?

Chapter 13. Organizing Your Model: Packages

Section 13.1. Packages

Section 13.2. Namespaces and Classes Referring to Each Other

Section 13.3. Element Visibility

Section 13.4. Package Dependency

Section 13.5. Importing and Accessing Packages

Section 13.6. Managing Package Dependencies

Section 13.7. Using Packages to Organize Use Cases

Section 13.8. What's Next?

Chapter 14. Modeling an Object's State: State Machine Diagrams

Section 14.1. Essentials

Section 14.2. States

Section 14.3. Transitions

Section 14.4. States in Software

Section 14.5. Advanced State Behavior

Section 14.6. Composite States

Section 14.7. Advanced Pseudostates

Section 14.8. Signals

Section 14.9. Protocol State Machines

Section 14.10. What's Next?

Chapter 15. Modeling Your Deployed System: Deployment Diagrams

Section 15.1. Deploying a Simple System

Section 15.2. Deployed Software: Artifacts

Section 15.3. What Is a Node?

Section 15.4. Hardware and Execution Environment Nodes

Section 15.5. Communication Between Nodes

Section 15.6. Deployment Specifications

Section 15.7. When to Use a Deployment Diagram

Section 15.8. What's Next?

Appendix A. Object Constraint Language

Section A.1. Building OCL Expressions

Section A.2. Types

Section A.3. Operators

Section A.4. Pulling It Together

Section A.5. Context

Section A.6. Types of Constraints

Section A.7. OCL Automation

Appendix B. Adapting UML: Profiles

Section B.1. What Is a Profile?

Section B.2. Stereotypes

Section B.3. Tagged Values

Section B.4. Constraints

Section B.5. Creating a Profile

Section B.6. Working with the Meta-Model

Section B.7. Using a Profile

Section B.8. Why Bother with Profiles?

Appendix C. A History of UML

Section C.1. Take One Part OOAD...

Section C.2. ...with a Sprinkling of OOSE...

Section C.3. ...Add a Dash of OMT...

Section C.4. ...and Bake for 10 to 15 Years

About the Authors

Colophon

Index