Log In
Or create an account ->
Imperial Library
Home
About
News
Upload
Forum
Help
Login/SignUp
Index
Learning UML 2.0
Preface
Audience
About This Book
Assumptions This Book Makes
Conventions Used in This Book
Using Code Examples
Safari® Enabled
How to Contact Us
Acknowledgments
From the Authors
From Russ Miles
From Kim Hamilton
1. Introduction
1.1. What's in a Modeling Language?
1.1.1. Detail Overload: Modeling with Code
1.1.2. Verbosity, Ambiguity, Confusion: Modeling with Informal Languages
1.1.3. Getting the Balance Right: Formal Languages
1.2. Why UML 2.0?
1.3. Models and Diagrams
1.4. "Degrees" of UML
1.5. UML and the Software Development Process
1.6. Views of Your Model
1.7. A First Taste of UML
1.7.1. Notes
1.7.2. Stereotypes
1.7.2.1. Stereotype applied to classes (see Chapter 4 and Chapter 5)
1.7.2.2. Stereotypes applied to components (see Chapter 12)
1.7.2.3. Stereotypes applied to artifacts (see Chapter 15)
1.7.2.4. Tagged values
1.8. Want More Information?
2. Modeling Requirements: Use Cases
2.1. Capturing a System Requirement
2.1.1. Outside Your System: Actors
2.1.1.1. Tricky actors
2.1.1.2. Refining actors
2.1.2. Use Cases
2.1.3. Communication Lines
2.1.4. System Boundaries
2.1.5. Use Case Descriptions
2.2. Use Case Relationships
2.2.1. The <<include>> Relationship
2.2.2. Special Cases
2.2.3. The <<extend>> Relationship
2.3. Use Case Overview Diagrams
2.4. What's Next?
3. Modeling System Workflows: Activity Diagrams
3.1. Activity Diagram Essentials
3.2. Activities and Actions
3.3. Decisions and Merges
3.4. Doing Multiple Tasks at the Same Time
3.5. Time Events
3.6. Calling Other Activities
3.7. Objects
3.7.1. Showing Objects Passed Between Actions
3.7.2. Showing Action Inputs and Outputs
3.7.3. Showing How Objects Change State During an Activity
3.7.4. Showing Input to and Output from an Activity
3.8. Sending and Receiving Signals
3.9. Starting an Activity
3.10. Ending Activities and Flows
3.10.1. Interrupting an Activity
3.10.2. Ending a Flow
3.11. Partitions (or Swimlanes)
3.12. Managing Complex Activity Diagrams
3.12.1. Connectors
3.12.2. Expansion Regions
3.13. What's Next?
4. Modeling a System's Logical Structure: Introducing Classes and Class Diagrams
4.1. What Is a Class?
4.1.1. Abstraction
4.1.2. Encapsulation
4.2. Getting Started with Classes in UML
4.3. Visibility
4.3.1. Public Visibility
4.3.2. Protected Visibility
4.3.3. Package Visibility
4.3.4. Private Visibility
4.4. Class State: Attributes
4.4.1. Name and Type
4.4.2. Multiplicity
4.4.3. Attribute Properties
4.4.4. Inline Attributes Versus Attributes by Association
4.5. Class Behavior: Operations
4.5.1. Parameters
4.5.2. Return Types
4.6. Static Parts of Your Classes
4.7. What's Next
5. Modeling a System's Logical Structure: Advanced Class Diagrams
5.1. Class Relationships
5.1.1. Dependency
5.1.2. Association
5.1.2.1. Association classes
5.1.3. Aggregation
5.1.4. Composition
5.1.5. Generalization (Otherwise Known as Inheritance)
5.1.5.1. Generalization and implementation reuse
5.1.5.2. Multiple inheritance
5.2. Constraints
5.3. Abstract Classes
5.4. Interfaces
5.5. Templates
5.6. What's Next
6. Bringing Your Classes to Life: Object Diagrams
6.1. Object Instances
6.2. Links
6.2.1. Links and Constraints
6.3. Binding Class Templates
6.4. What's Next?
7. Modeling Ordered Interactions: Sequence Diagrams
7.1. Participants in a Sequence Diagram
7.1.1. Participant Names
7.2. Time
7.3. Events, Signals, and Messages
7.3.1. Message Signatures
7.4. Activation Bars
7.5. Nested Messages
7.6. Message Arrows
7.6.1. Synchronous Messages
7.6.2. Asynchronous Messages
7.6.3. The Return Message
7.6.4. Participant Creation and Destruction Messages
7.7. Bringing a Use Case to Life with a Sequence Diagram
7.7.1. A Top-Level Sequence Diagram
7.7.2. Breaking an Interaction into Separate Participants
7.7.3. Applying Participant Creation
7.7.4. Applying Participant Deletion
7.7.5. Applying Asynchronous Messages
7.8. Managing Complex Interactions with Sequence Fragments
7.8.1. Using a Sequence Fragment: The ref Fragment
7.8.2. A Brief Overview of UML 2.0's Fragment Types
7.9. What's Next?
8. Focusing on Interaction Links: Communication Diagrams
8.1. Participants, Links, and Messages
8.1.1. Messages Occurring at the Same Time
8.1.2. Invoking a Message Multiple Times
8.1.3. Sending a Message Based on a Condition
8.1.4. When a Participant Sends a Message to Itself
8.2. Fleshing out an Interaction with a Communication Diagram
8.3. Communication Diagrams Versus Sequence Diagrams
8.3.1. How the Fight Shapes Up
8.3.2. The Main Event
8.4. What's Next?
9. Focusing on Interaction Timing: Timing Diagrams
9.1. What Do Timing Diagrams Look Like?
9.2. Building a Timing Diagram from a Sequence Diagram
9.2.1. Timing Constraints in System Requirements
9.3. Applying Participants to a Timing Diagram
9.4. States
9.5. Time
9.5.1. Exact Time Measurements and Relative Time Indicators
9.6. A Participant's State-Line
9.7. Events and Messages
9.8. Timing Constraints
9.8.1. Timing Constraint Formats
9.8.2. Applying Timing Constraints to States and Events
9.9. Organizing Participants on a Timing Diagram
9.10. An Alternate Notation
9.11. What's Next?
10. Completing the Interaction Picture: Interaction Overview Diagrams
10.1. The Parts of an Interaction Overview Diagram
10.2. Modeling a Use Case Using an Interaction Overview
10.2.1. Pulling Together the Interactions
10.2.2. Gluing the Interactions Together
10.3. What's Next?
11. Modeling a Class's Internal Structure: Composite Structures
11.1. Internal Structure
11.1.1. When Class Diagrams Won't Work
11.1.2. Parts of a Class
11.1.3. Connectors
11.1.4. Alternate Multiplicity Notations
11.1.5. Properties
11.1.6. Showing Complex Relationships Between Contained Items
11.1.7. Internal Structure Instances
11.2. Showing How a Class Is Used
11.3. Showing Patterns with Collaborations
11.4. What's Next?
12. Managing and Reusing Your System's Parts: Component Diagrams
12.1. What Is a Component?
12.2. A Basic Component in UML
12.3. Provided and Required Interfaces of a Component
12.3.1. Ball and Socket Notation for Interfaces
12.3.2. Stereotype Notation for Interfaces
12.3.3. Listing Component Interfaces
12.4. Showing Components Working Together
12.5. Classes That Realize a Component
12.6. Ports and Internal Structure
12.6.1. Delegation Connectors
12.6.2. Assembly Connectors
12.7. Black-Box and White-Box Component Views
12.8. What's Next?
13. Organizing Your Model: Packages
13.1. Packages
13.1.1. Contents of a Package
13.1.2. UML Tool Variation
13.2. Namespaces and Classes Referring to Each Other
13.3. Element Visibility
13.4. Package Dependency
13.5. Importing and Accessing Packages
13.6. Managing Package Dependencies
13.7. Using Packages to Organize Use Cases
13.8. What's Next?
14. Modeling an Object's State: State Machine Diagrams
14.1. Essentials
14.2. States
14.3. Transitions
14.3.1. Transition Variations
14.4. States in Software
14.5. Advanced State Behavior
14.5.1. Internal Behavior
14.5.2. Internal Transitions
14.6. Composite States
14.7. Advanced Pseudostates
14.8. Signals
14.9. Protocol State Machines
14.10. What's Next?
15. Modeling Your Deployed System: Deployment Diagrams
15.1. Deploying a Simple System
15.2. Deployed Software: Artifacts
15.2.1. Deploying an Artifact to a Node
15.2.2. Tying Software to Artifacts
15.3. What Is a Node?
15.4. Hardware and Execution Environment Nodes
15.4.1. Showing Node Instances
15.5. Communication Between Nodes
15.6. Deployment Specifications
15.7. When to Use a Deployment Diagram
15.8. What's Next?
A. Object Constraint Language
A.1. Building OCL Expressions
A.2. Types
A.3. Operators
A.4. Pulling It Together
A.5. Context
A.6. Types of Constraints
A.7. OCL Automation
B. Adapting UML: Profiles
B.1. What Is a Profile?
B.2. Stereotypes
B.3. Tagged Values
B.4. Constraints
B.5. Creating a Profile
B.6. Working with the Meta-Model
B.7. Using a Profile
B.8. Why Bother with Profiles?
C. A History of UML
C.1. Take One Part OOAD...
C.2. ...with a Sprinkling of OOSE...
C.3. ...Add a Dash of OMT...
C.4. ...and Bake for 10 to 15 Years
About the Authors
Colophon
← Prev
Back
Next →
← Prev
Back
Next →