Cover image for UML 2.0 in a Nutshell

UML 2.0 in a Nutshell

Author Neil Pitman , Dan Pilone
Release Date: 2005/06/01
ISBN: 0596007957
Topic:
0%
22
Chapters
0-1
Hours read
0k
Total Words
    Start Reading Now    
       Add to Wishlist       
View table of contents

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. A Note Regarding Supplemental Files
  2. Dedication
  3. 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
  4. 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
  5. 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
  6. 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
  7. 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
  8. 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
  9. 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
  10. 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
  11. 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
  12. 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
  13. 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
  14. 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
  15. 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
  16. 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
  17. 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
  18. About the Authors
  19. Colophon
  20. Copyright
18.117.142.248