|
Visual Modeling with Rational Rose 2002 and UML (Object Technology S.) (3rd Revised edition)
The third edition of this popular book retains the practical approach to teaching visual modeling techniques and the industry standard Unified Modeling Language. Author Terry Quatrani, the Rose Evangelist from Rational Software Corporation, still uses the simplified case study (a course registration system for a fictional university) that has taught
thousands of readers how to analyze and design an application using UML, and how to implement the application using Rational Rose. The screen shots and Rational Rose instructions have been updated to reflect the release of Rational Rose 2002. After a short history of the evolution of UML and a guide to the basic terms of software engineering, the book introduces the concept of requirements, use cases, and class diagrams. Further chapters move toward defining an architecture and even refining the design within the incremental methodology of Rational Rose.
Contents:
(NOTE: Each chapter concludes with a Summary.) Foreword
Preface
1
Introduction
What Is Visual Modeling? The Triangle for Success
The Role of Notation
History of the UML
The Role of Process
What Is Iterative and Incremental Development? The Rational Unified Process
The Rational Rose Tool
2
Beginning a Project
Defining the Right Project
Eastern State University (ESU) Background
Risks for the Course Registration Problem
ESU Course Registration Problem Statement
3
Creating Use Cases
System Behavior
Actors
Use Cases
Use Case Relationships
Use Case Diagrams
Activity Diagrams
4
Finding Classes
What Is an Object? State, Behavior, and Identity
What Is a Class? Stereotypes and Classes
Discovering Classes
Documenting Classes
Packages
Objects and Classes in the ESU Course Registration Problem
Class Diagrams
5
Discovering Object Interaction
Use Case Realization
Documenting Scenarios
Sequence Diagrams
Sequence Diagrams and Boundary Classes
Complexity and Sequence Diagrams
Collaboration Diagrams
Why Are There Two Different Diagrams? Sequence Diagram for the ESU Course Registration System
6
Specifying Relationships
The Need for Relationships
Association Relationships
Aggregation Relationships
Association or Aggregation? Naming Relationships
Role Names
Multiplicity Indicators
Reflexive Relationships
Finding Relationships
Package Relationships
7
Adding Behavior and Structure
Representing Behavior and Structure
Creating Operations
Documenting Operations
Relationships and Operation Signatures
Creating Attributes
Documenting Attributes
Displaying Attributes and Operations
Association Classes
8
Discovering Inheritance
Inheritance
Generalization
Specialization
Inheritance Trees
Single Inheritance versus Multiple Inheritance
Inheritance versus Aggregation
9
Analyzing Object Behavior
Modeling Dynamic Behavior
States
State Transitions
Special States
State Transition Details
State Details
10
Checking the Model
Why Homogenize? Combining Classes
Splitting Classes
Eliminating Classes
Consistency Checking
Scenario Walk-Through
Event Tracing
Documentation Review
11
Designing the System Architecture
The Need for Architecture
The Architecture Team
The 4+1 View of Architecture
The Logical View
The Implementation View
The Process View
The Deployment View
The Use Case View
12
Building the Iterations
The Iteration Planning Process
Designing the User Interface
Adding Design Classes
The Emergence of Patterns
Designing Relationships
Designing Attributes and Operations
Designing for Inheritance
Coding, Testing, and Documenting the Iteration
Using Reverse Engineering to Set the Stage for the Next Iteration
Appendix A: Code Generation and Reverse Engineering with C++
Appendix B: Code Generation and Reverse Engineering with Visual C++ and Visual Basic
Appendix C: A Visual Basic Example
Glossary
Index
0201729326T09262002
Brief Description:
Shows how to use a tool (Rational Rose 2002), a process (the Rational Unified Process), and a language (the UML) to successfully visualize, specify, document, and construct a software system. This book covers topics that include: creating use cases; finding objects and classes; UML stereotypes and packages; iteration planning process; and more.
|
