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