UML2和统一过程：实用面向对象的分析与设计（第2版 英文版）

Contents

Part 1 Introducing UML and UP

1 What is UML?

1.1 Chapter roadmap

1.2 What is UML?

1.3 The birth of UML

1.4 MDA-the future of UML

1.5 Why “unified”?

1.6 Objects and UML

1.7 UML structure

1.8 UML building blocks

1.9 UML common mechanisms

1.10 Architecture

1.11 What we have learned

2 What is the Unified Process?

2.1 Chapter roadmap

2.2 What is UP?

2.3 The birth of UP

2.4 UP and the Rational Unified Process

2.5 Instantiating UP for your project

2.6 UP axioms

2.7 UP is an iterative and incremental process

2.8 Upstructure

2.9 UP phases

2.10 What we have learned

Part 2 Requirements

3 The requirements workflow

3.1 Chapter roadmap

3.2 The requirements workflow

3.3 Software requirements-metamodel

3.4 Requirements workflow detail

3.5 The importance of requirements

3.6 Defining requirements

3.7 Finding requirements

3.8 What we have learned

4 Use case modeling

4.1 Chapter roadmap

4.2 Use case modeling

4.3 UP activity:Find actors and use cases

4.4 Up activity:Detail a use case

4.5 Use case specification

4.6 Requirements tracing

4.7 When to apply use case modeling

4.8 What we have learned

5 Advanced use case modeling

5.1 Chapter roadmap

5.2 Actor generalization

5.3 Use case generalization

5.4 <include>

5.5 <extend>

5.6 When to use advanced features

5.7 Hints and tips for writing u se cases

5.8 What we have learned

Part 3 Analysis

6 The analysis workflow

6.1 Chapter roadmap

6.2 The analysis workflow

6.3 Analysis artifacts-metamodel

6.4 Analysis workflow detail

6.5 Analysis model-rules of thumb

6.6 What we have learned

7 Object s and classes

7.1 Chapter roadmap

7.2 What are objects

7.3 UML object notation

7.4 What are classes?

7.5 UML class notation

7.6 Scope

7.7 Object construction and destruction

7.8 What we have learned

8 Finding analysis classes

8.1 Chapter roadmap

8.2 UP activity: Analyze a use case

8.3 What are analysis classes?

8.4 Finding classes

8.5 Creating a first-cut analysis model

8.6 What we have learned

9 Relationships

9.1 Chapter roadmap

9.2 What is a relationship?

9.3 What is a link?

9.4 What is an association?

9.5 What is a dependency?

9.6 What we have learned

10 Inheritance and polymorphism

10.1 Chapter roadmap

10.2 Generalization

10.3 Class inheritance

10.4 Polymophism

10.5 Advanced generalization

10.6 What we have learned

11 Analysis packages

11.1 Chapter roadmap

11.2 What is a package?

11.3 Packages and namespaces

11.4 Nested packages

11.5 Package dependencies

11.6 Package generalization

11.7 Architectural analysis

11.8 Wha t we have learned

12 Use case realization

12.1 Chapter roadmap

12.2 UP zctivity:Analyze a use case

12.3 What are use case realizations?

12.4 Use case realization-elements

12.5 Interactions

12.6 Lifelines

12.7 Messages

12.8 Interaction deagrams

12.9 Sequence diagrams

12.10 Combined fragments and operators

12.11 Communication diagrams

12.12 What we have learned

13 Advanced use case realization

13.1 Chapter roadmap

13.2 Interaction occurrences

13.3 Continuations

13.4 What we have learned

14 Activity diagrams

14.1 Chapter roadmap

14.2 What are activity diagrams?

14.3 Activity diagrams and the UP

14.4 Activities

14.5 Activity semantice

14.6 Activity partitions

14.7 Action nodes

14.8 Control nodes

14.9 Object nodes

14.10 Pins

14.11 What we have learned

15 Advanced activity diagrams

15.1 Chapter roadmap

15.2 Connectors

15.3 Interruptible activity regions

15.4 Exception handling

15.5 Expansion nodes

15.6 Sending signals and accepting events

15.7 Streaming

15.8 Advanced object flow features

15.9 Multicast and multireceive

15.10 Parameter sets

15.11 <centralBuffer> node

15.12 Interaction overview diagrams

15.13 What we have learned

Part 4 Design

16 The design workflow

16.1 Chapter roadmap

16.2 The design workflow

16.3 Design artifacts-metamodel

16.4 Design workflow detail

16.5 UP activity:Architectural design

16.6 What we have learned

17 Design classes

17.1 Chapter roadmap

17.2 UP activity:Design a class

17.3 What are design classes?

17.4 Anatomy of a design class

17.5 Well-formed design classes

17.6 Inheritance

17.7 Templates

17.8 Nested clsases

17.9 What we have learned

18 Refining analysis relationships

18.1 Chapter roadmap

18.2 Design relationships

18.3 Aggregation and composition

18.4 Aggregation semantics

18.5 Composition Semantics

18.6 How to refine analysis relationships

18.7 One-to-one associations

18.8 Many—to—one associations

18.9 One-to-many associations

18.10 Collections

18.11 Reified relationships

18.12 Exploring composition with structured classes

18.13 What we have learned

19 Interfaces and components

19.1 Chapter roadmap

19.2 UP activity:Design a subsystem

19.3 What is an interface?

19.4 Provided and required interfaces

19.5 Interface realization vs.inheritance

19.6 Ports

19.7 Interfaces and component-based development

19.8 What is a component?

19.9 Component stereotypes

19.10 Subsystems

19.11 Finding interfaces

19.12 Designing with interfaces

19.13 Advantages and disadvantages of interfaces

19.14 What we have learned

20 Use case realization-design

20.1Chapter roadmap

20.2 UP activity:Design a use case

20.3 Use case realization-design

20.4 Interaction diagrams in design

20.5 Modeling concurrency

20.6 Subsystem interactions

20.7 Timing diagrams

20.8 Example of use case realization-design

20.9 What we have learned

21 State machines

21.1 Chapter readmap

21.2 State machines

21.3 State machines and the UP

21.4 State machine diagrams

21.5 States

21.6 Transitions

21.7 Events

21.8 What we have learned

22 Advanced state machines

22.1 Chapter roadmap

22.2 Composite states

22.3 Submachine states

22.4 Submachine communication

22.5 History

22.6 What we have learned

Part 5 Implementation

23 The implementation workflow

23.1 Chapter roadmap

23.2 The implementation workflow

23.3 Implementation artifacts-metamodel

23.4 Implementation workflow detail

23.5 Artifacts

23.6 What we have learned

24 Deployment

24.1 Chapter roadmap

24.2 UP activity: Architectural implementation

24.3 The deployment diagram

24.4 Nodes

24.5 Artifacts

24.6 Deployment

24.7 What we have learned

Part 6 Supplementary material

25 Introduction to OCL

25.1 Chapter roadmap

25.2 What is the Object Constraint Language(OCL)?

25.3 Why use OCL?

25.4 OCL expression syntax

25.5 Package context and pathnames

25.6 The expression context

25.7 Types of OCL expressions

25.8 The expressiong body

25.9 OCL navigation

25.10 Types of OCL expression in detail

25.11 OCL in other types of diagrams

25.12 Advanced topics

25.13 What we have learned

Appendix 1:Example use case model

Appendix 2:XMLand use cases

Bibliography

Index