Learning UML 2.0 Russ Miles, Kim Hamilton

Kup polskie wydanie:

Spis treści książki

• 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. Whats 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 Chapters 4 and 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. Whats 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. Whats Next?
• 4. Modeling a Systems 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. Whats Next
• 5. Modeling a Systems 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. Whats 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. Whats 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.0s Fragment Types
  • 7.9. Whats 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. Whats 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 Participants 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. Whats 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. Whats Next?
• 11. Modeling a Classs Internal Structure: Composite Structures
  • 11.1. Internal Structure
    • 11.1.1. When Class Diagrams Wont 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. Whats Next?
• 12. Managing and Reusing Your Systems 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. Whats 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. Whats Next?
• 14. Modeling an Objects 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. Whats 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. Whats 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
• Index
• About the Authors
• Colophon
• Copyright

pokaż cały spis treści

ukryj recenzje