You are previewing UML 2.0 in a Nutshell.
O'Reilly logo
UML 2.0 in a Nutshell

Book Description

System developers have used modeling languages for decades to specify, visualize, construct, and document systems. The Unified Modeling Language (UML) is one of those languages. UML makes it possible for team members to collaborate by providing a common language that applies to a multitude of different systems. Essentially, it enables you to communicate solutions in a consistent, tool-supported language. Today, UML has become the standard method for modeling software systems, which means you're probably confronting this rich and expressive language more than ever before. And even though you may not write UML diagrams yourself, you'll still need to interpret diagrams written by others. UML 2.0 in a Nutshell from O'Reilly feels your pain. It's been crafted for professionals like you who must read, create, and understand system artifacts expressed using UML. Furthermore, it's been fully revised to cover version 2.0 of the language. This comprehensive new edition not only provides a quick-reference to all UML 2.0 diagram types, it also explains key concepts in a way that appeals to readers already familiar with UML or object-oriented programming concepts. Topics include:

  • The role and value of UML in projects

  • The object-oriented paradigm and its relation to the UML

  • An integrated approach to UML diagrams

  • Class and Object, Use Case, Sequence, Collaboration, Statechart, Activity, Component, and Deployment Diagrams

  • Extension Mechanisms

  • The Object Constraint Language (OCL)

If you're new to UML, a tutorial with realistic examples has even been included to help you quickly familiarize yourself with the system.

Table of Contents

  1. UML 2.0 in a Nutshell
    1. SPECIAL OFFER: Upgrade this ebook with O’Reilly
    2. A Note Regarding Supplemental Files
    3. Dedication
    4. Preface
      1. About This Book
      2. How to Use This Book
      3. Typographic Conventions
      4. Safari Enabled
      5. Comments and Questions
      6. Acknowledgments
        1. From Dan
        2. From Neil
    5. 1. Fundamentals of UML
      1. 1.1. Getting Started
      2. 1.2. Background
      3. 1.3. UML Basics
        1. 1.3.1. Designing Software
        2. 1.3.2. Business Process Modeling
      4. 1.4. UML Specifications
      5. 1.5. Putting UML to Work
        1. 1.5.1. UML Profiles
      6. 1.6. Modeling
        1. 1.6.1. Diagrams
        2. 1.6.2. Views
        3. 1.6.3. Notes
        4. 1.6.4. Classifiers and Adornments
      7. 1.7. UML Rules of Thumb
    6. 2. Class Diagrams
      1. 2.1. Classes
        1. 2.1.1. Objects
      2. 2.2. Attributes
        1. 2.2.1. Inlined Attributes
        2. 2.2.2. Attributes by Relationship
        3. 2.2.3. Derived Attributes
        4. 2.2.4. Attribute Multiplicity
          1. 2.2.4.1. Ordering
          2. 2.2.4.2. Uniqueness
          3. 2.2.4.3. Collection types
        5. 2.2.5. Attribute Properties
        6. 2.2.6. Constraints
        7. 2.2.7. Static Attributes
      3. 2.3. Operations
        1. 2.3.1. Operation Constraints
          1. 2.3.1.1. Preconditions
          2. 2.3.1.2. Postconditions
          3. 2.3.1.3. Body conditions
          4. 2.3.1.4. Query operations
          5. 2.3.1.5. Exceptions
        2. 2.3.2. Static Operations
      4. 2.4. Methods
      5. 2.5. Abstract Classes
      6. 2.6. Relationships
        1. 2.6.1. Dependency
        2. 2.6.2. Association
          1. 2.6.2.1. Navigability
          2. 2.6.2.2. Naming an association
          3. 2.6.2.3. Multiplicity
        3. 2.6.3. Aggregation
        4. 2.6.4. Composition
        5. 2.6.5. Generalization
        6. 2.6.6. Association Classes
        7. 2.6.7. Association Qualifiers
      7. 2.7. Interfaces
      8. 2.8. Templates
      9. 2.9. Variations on Class Diagrams
        1. 2.9.1. XML Schemas
        2. 2.9.2. Database Schemas
    7. 3. Package Diagrams
      1. 3.1. Representation
      2. 3.2. Visibility
      3. 3.3. Importing and Accessing Packages
      4. 3.4. Merging Packages
      5. 3.5. Variations on Package Diagrams
        1. 3.5.1. Structuring a Project with Package Diagrams
        2. 3.5.2. Use Case Packages
        3. 3.5.3. Directed Dependency Graphs
    8. 4. Composite Structures
      1. 4.1. Composite Structures
        1. 4.1.1. Connectors
        2. 4.1.2. Ports
          1. 4.1.2.1. Required and provided interfaces
          2. 4.1.2.2. Realizing port implementations
          3. 4.1.2.3. Multiple connectors
          4. 4.1.2.4. Port multiplicity
          5. 4.1.2.5. Port typing
        3. 4.1.3. Structured Classes and Properties
      2. 4.2. Collaborations
      3. 4.3. Collaboration Occurrences
    9. 5. Component Diagrams
      1. 5.1. Components
        1. 5.1.1. Component Dependencies
      2. 5.2. Component Views
        1. 5.2.1. Black-Box View
          1. 5.2.1.1. Assembly connectors
          2. 5.2.1.2. Interface dependencies
          3. 5.2.1.3. Component compartments
        2. 5.2.2. White-Box View
          1. 5.2.2.1. Realization compartment
          2. 5.2.2.2. Classifier dependencies
          3. 5.2.2.3. Ports and connectors
        3. 5.2.3. Component Stereotypes
    10. 6. Deployment Diagrams
      1. 6.1. Artifacts
        1. 6.1.1. Artifact Instances
        2. 6.1.2. Manifestations
      2. 6.2. Nodes
        1. 6.2.1. Execution Environments
          1. 6.2.1.1. Execution environment stereotypes
          2. 6.2.1.2. Explicit services
        2. 6.2.2. Devices
        3. 6.2.3. Communication Paths
      3. 6.3. Deployment
        1. 6.3.1. Deployment Representation
        2. 6.3.2. Deployment Specifications
      4. 6.4. Variations on Deployment Diagrams
    11. 7. Use Case Diagrams
      1. 7.1. Use Cases
      2. 7.2. Actors
        1. 7.2.1. Actor/Use Case Associations
        2. 7.2.2. System Boundaries
        3. 7.2.3. Using Actors to Identify Functionality
      3. 7.3. Advanced Use Case Modeling
        1. 7.3.1. Actor and Use Case Generalization
        2. 7.3.2. Use Case Inclusion
        3. 7.3.3. Use Case Extension
      4. 7.4. Use Case Scope
    12. 8. Statechart Diagrams
      1. 8.1. Behavioral State Machines
      2. 8.2. States
        1. 8.2.1. Composite States
          1. 8.2.1.1. Regions
        2. 8.2.2. Submachine States
        3. 8.2.3. Transitions
          1. 8.2.3.1. Transition types
          2. 8.2.3.2. Signal symbols
          3. 8.2.3.3. Transitions and composite states
        4. 8.2.4. Activities
      3. 8.3. State Machine Extension
      4. 8.4. Protocol State Machines
      5. 8.5. Pseudostates
      6. 8.6. Event Processing
        1. 8.6.1. Dispatch
        2. 8.6.2. Deferred Events
      7. 8.7. Variations on Statechart Diagrams
    13. 9. Activity Diagrams
      1. 9.1. Activities and Actions
        1. 9.1.1. Activity Edges
          1. 9.1.1.1. Control flows
          2. 9.1.1.2. Object flows
          3. 9.1.1.3. Connectors
      2. 9.2. Tokens
      3. 9.3. Activity Nodes
        1. 9.3.1. Parameter Nodes
        2. 9.3.2. Object Nodes
        3. 9.3.3. Pins
        4. 9.3.4. Control Nodes
          1. 9.3.4.1. Initial nodes
          2. 9.3.4.2. Decision and merge nodes
          3. 9.3.4.3. Fork and join nodes
          4. 9.3.4.4. Final nodes
      4. 9.4. Advanced Activity Modeling
        1. 9.4.1. Activity Partitions
        2. 9.4.2. Exception Handling
        3. 9.4.3. Expansion Regions
        4. 9.4.4. Looping
        5. 9.4.5. Streaming
        6. 9.4.6. Interruptible Activity Regions
        7. 9.4.7. Central Buffer Nodes
        8. 9.4.8. Data Store Nodes
    14. 10. Interaction Diagrams
      1. 10.1. What Are Interactions?
      2. 10.2. Interaction Participants
      3. 10.3. Messages
      4. 10.4. Execution Occurrences
      5. 10.5. State Invariants
      6. 10.6. Event Occurrences
      7. 10.7. Traces
      8. 10.8. Combined Fragments
        1. 10.8.1. Guard Conditions
        2. 10.8.2. Interaction Operators
          1. 10.8.2.1. Alternatives
          2. 10.8.2.2. Option
          3. 10.8.2.3. Break
          4. 10.8.2.4. Parallel
          5. 10.8.2.5. Weak sequencing
          6. 10.8.2.6. Strict sequencing
          7. 10.8.2.7. Negative
          8. 10.8.2.8. Critical region
          9. 10.8.2.9. Ignore/consider
          10. 10.8.2.10. Assertion
          11. 10.8.2.11. Loop
      9. 10.9. Interaction Occurrences
      10. 10.10. Decomposition
      11. 10.11. Continuations
      12. 10.12. Sequence Timing
      13. 10.13. Alternate Interaction Notations
        1. 10.13.1. Communication Diagrams
        2. 10.13.2. Interaction Overview Diagrams
        3. 10.13.3. Timing Diagrams
    15. 11. Tagged Values, Stereotypes, and UML Profiles
      1. 11.1. Modeling and UML in Context
      2. 11.2. Stereotypes
      3. 11.3. Tagged Values
      4. 11.4. Constraints
      5. 11.5. UML Profiles
      6. 11.6. Tools and How They Use Profiles
    16. 12. Effective Diagramming
      1. 12.1. Wallpaper Diagrams
        1. 12.1.1. Modeling Versus Diagramming
        2. 12.1.2. Structure and Interrelationships Among Classes
        3. 12.1.3. Separate Inheritance and Class Interrelationships
      2. 12.2. Sprawling Scope
      3. 12.3. One Diagram/One Abstraction
      4. 12.4. Besides UML
    17. A. MDA: Model-Driven Architecture
      1. A.1. What Is MDA?
      2. A.2. The Models of MDA
      3. A.3. Design Decisions
      4. A.4. Sewing the Models Together
      5. A.5. Transforming Models
      6. A.6. Languages to Formally Describe MDA
    18. B. The Object Constraint Language
      1. B.1. OCL Basics
        1. B.1.1. Basic Types
        2. B.1.2. Casting
      2. B.2. OCL Syntax
        1. B.2.1. Constraints on Classifiers
        2. B.2.2. Constraints on Operations
        3. B.2.3. Constraints on Attributes
      3. B.3. Advanced OCL Modeling
        1. B.3.1. Conditionals
        2. B.3.2. Variable Declaration
        3. B.3.3. Operator Precedence
        4. B.3.4. Built-in Object Properties
        5. B.3.5. Collections
    19. About the Authors
    20. Colophon
    21. SPECIAL OFFER: Upgrade this ebook with O’Reilly