Learning UML 2.0 - Helion

ebook

Autor: Russ Miles, Kim Hamilton
ISBN: 978-05-965-5522-1
stron: 290, Format: ebook
Data wydania: 2006-04-25
Księgarnia: Helion

Cena książki: 135,15 zł (poprzednio: 157,15 zł)
Oszczędzasz: 14% (-22,00 zł)

Osoby, które kupiły tę książkę, wybierały także »

Tagi: Programowanie | UML - Programowanie

"Since its original introduction in 1997, the Unified Modeling Language has revolutionized software development. Every integrated software development environment in the world--open-source, standards-based, and proprietary--now supports UML and, more importantly, the model-driven approach to software development. This makes learning the newest UML standard, UML 2.0, critical for all software developers--and there isn't a better choice than this clear, step-by-step guide to learning the language."
--Richard Mark Soley, Chairman and CEO, OMG

If you're like most software developers, you're building systems that are increasingly complex. Whether you're creating a desktop application or an enterprise system, complexity is the big hairy monster you must manage.

The Unified Modeling Language (UML) helps you manage this complexity. Whether you're looking to use UML as a blueprint language, a sketch tool, or as a programming language, this book will give you the need-to-know information on how to apply UML to your project. While there are plenty of books available that describe UML, Learning UML 2.0 will show you how to use it. Topics covered include:

Capturing your system's requirements in your model to help you ensure that your designs meet your users' needs

Modeling the parts of your system and their relationships

Modeling how the parts of your system work together to meet your system's requirements

Modeling how your system moves into the real world, capturing how your system will be deployed

Engaging and accessible, this book shows you how to use UML to craft and communicate your project's design. Russ Miles and Kim Hamilton have written a pragmatic introduction to UML based on hard-earned practice, not theory. Regardless of the software process or methodology you use, this book is the one source you need to get up and running with UML 2.0.

Russ Miles is a software engineer for General Dynamics UK, where he works with Java and Distributed Systems, although his passion at the moment is Aspect Orientation and, in particular, AspectJ. Kim Hamilton is a senior software engineer at Northrop Grumman, where she's designed and implemented a variety of systems including web applications and distributed systems, with frequent detours into algorithms development.

Osoby które kupowały "Learning UML 2.0", wybierały także:

Zen Steve'a Jobsa 29,67 zł, (8,90 zł -70%)
ASP.NET MVC. Kompletny przewodnik dla programistów interaktywnych aplikacji internetowych w Visual Studio 86,77 zł, (26,90 zł -69%)
jQuery, jQuery UI oraz jQuery Mobile. Receptury 57,74 zł, (17,90 zł -69%)
Scratch. Komiksowa przygoda z programowaniem 36,06 zł, (11,90 zł -67%)
Baltie. Kurs video. Poziom pierwszy. Elementarz programowania w języku wizualnym 59,00 zł, (26,55 zł -55%)

Spis treści

Learning UML 2.0 eBook -- spis treści

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