UML and the unified process : practical object-oriented analysis and design
Author(s)
Bibliographic Information
UML and the unified process : practical object-oriented analysis and design
（The Addison-Wesley object technology series / Grady Booch, Ivan Jacobson, James Rumbaugh）
Addison-Wesley, c2002
Available at / 10 libraries
-
No Libraries matched.
- Remove all filters.
Note
Includes bibliographical references (p. [381]) and index
Description and Table of Contents
Description
*This book gives the reader a quick, focused tour through the early stages of the Object Oriented software development process - Analysis & Design. *It introduces and explains the need-to-know concepts and key elements of both UML (Unified Modelling Language) and the Unified Process. *It will get the reader up to speed on successful techniques that he can immediately apply & use - the emphasis is on information that really is useful from the point of view of the OO analyst & designer, and that he can apply right away. *Accompanying web-site: complete worked example to illustrate how techniques learned in the book work in practice; links to other OO A&D resources and a bibliography.
Table of Contents
Part 1 Introducing UML and UP 1 1 What is UML? 3 1.1 Chapter roadmap 3 1.2 What is UML? 5 1.3 The birth of UML 5 1.4 Why "unified"? 7 1.5 Objects and UML 7 1.6 UML structure 8 1.7 UML building blocks 8 1.8 UML common mechanisms 12 1.9 Architecture 18 1.10 What we have learned 20 2 What is the Unified Process? 22 2.1 Chapter roadmap 22 2.2 What is UP? 23 2.3 The birth of UP 24 2.4 UP and the Rational Unified Process 27 2.5 Instantiating UP for your project 28 2.6 UP axioms 29 2.7 UP is an iterative and incremental process 29 2.8 UP structure 31 2.9 UP phases 33 2.10 What we have learned 38 Part 2 Requirements 41 3 The requirements workflow 43 3.1 Chapter roadmap 43 3.2 The requirements workflow 45 3.3 Software requirements - metamodel 46 3.4 Requirements workflow detail 47 3.5 The importance of requirements 49 3.6 Defining requirements 49 3.7 What we have learned 53 4 Use case modeling 55 4.1 Chapter roadmap 55 4.2 Use case modeling 57 4.3 UP activity: find actors and use cases 57 4.4 UP activity: detail a use case 63 4.5 Complex use cases 71 4.6 When to apply use case modeling 74 4.7 What we have learned 75 5 Advanced use case modeling 78 5.1 Chapter roadmap 78 5.2 Actor generalization 79 5.3 Use case generalization 81 5.4 A A'includeA A 84 5.5 A A'extendA A 86 5.6 When to use advanced features 90 5.7 What we have learned 91 Part 3 Analysis 95 6 The analysis workflow 97 6.1 Chapter roadmap 97 6.2 The analysis workflow 98 6.3 Analysis model - rules of thumb 100 6.4 What we have learned 102 7 Classes and objects 103 7.1 Chapter roadmap 103 7.2 What are objects? 104 7.3 UML object notation 108 7.4 What are classes? 110 7.5 UML class notation 114 7.6 Scope 120 7.7 Object construction and destruction 122 7.8 What we have learned 124 8 Finding analysis classes 127 8.1 Chapter roadmap 127 8.2 UP activity: analyze a use case 129 8.3 What are analysis classes? 129 8.4 Finding classes 134 8.5 Creating a first cut analysis model 138 8.6 What we have learned 139 9 Relationships 142 9.1 Chapter roadmap 142 9.2 What is a relationship? 144 9.3 What is a link? 144 9.4 What is an association? 147 9.5 What is a dependency? 160 9.6 What we have learned 166 10 Inheritance and polymorphism 170 10.1 Chapter roadmap 170 10.2 Generalization 171 10.3 Class inheritance 173 10.4 Polymorphism 176 10.5 What we have learned 180 11 Analysis packages 182 11.1 Chapter roadmap 182 11.2 What is a package? 182 11.3 Package dependencies 185 11.4 Transitivity 186 11.5 Nested packages 187 11.6 Package generalization 189 11.7 Package stereotypes 190 11.8 Architectural analysis 191 11.9 What we have learned 194 12 Use case realization 197 12.1 Chapter roadmap 197 12.2 UP activity: analyze a use case 199 12.3 What are use case realizations? 199 12.4 Use case realization - elements 200 12.5 Interaction diagrams 201 12.6 Collaborations and interactions 202 12.7 Collaboration diagrams 202 12.8 Sequence diagrams 220 12.9 What we have learned 227 13 Activity diagrams 231 13.1 Chapter roadmap 231 13.2 What are activity diagrams? 232 13.3 Action states 233 13.4 Subactivity states 234 13.5 Transitions 235 13.6 Decisions 236 13.7 Forks and joins 237 13.8 Swimlanes 238 13.9 Object flows 239 13.10 Signals 240 13.11 What we have learned 242 Part 4 Design 245 14 The design workflow 247 14.1 Chapter roadmap 247 14.2 The design workflow 249 14.3 Design artefacts - metamodel 250 14.4 Design workflow detail 253 14.5 Artefacts 254 14.6 What we have learned 255 15 Design classes 257 15.1 Chapter roadmap 257 15.2 What are design classes? 259 15.3 Anatomy of a design class 260 15.4 Well-formed design classes 261 15.5 Inheritance 264 15.6 Templates 268 15.7 Nested classes 270 15.8 What we have learned 271 16 Refining analysis relationships 274 16.1 Chapter roadmap 274 16.2 Design relationships 276 16.3 Aggregation and composition 276 16.4 Aggregation semantics 277 16.5 Composition semantics 280 16.6 How to refine analysis relationships 282 16.7 One-to-one associations 283 16.8 Many-to-one associations 283 16.9 One-to-many associations 284 16.10 Collections 284 16.11 Reified relationships 288 16.12 What we have learned 291 17 Interfaces and subsystems 296 17.1 Chapter roadmap 296 17.2 What is an interface? 297 17.3 Interfaces and component-based development 300 17.4 Finding interfaces 303 17.5 Designing with interfaces 303 17.6 What are subsystems? 304 17.7 Advantages and disadvantages of interfaces 309 17.8 What we have learned 310 18 Use case realization - design 313 18.1 Chapter roadmap 313 18.2 Use case realization - design 314 18.3 Interaction diagrams - design 314 18.4 Subsystem interactions 316 18.5 What we have learned 318 19 Basic statecharts 319 19.1 Chapter roadmap 319 19.2 Statechart diagrams 320 19.3 State machines and classes 321 19.4 Basic statechart syntax 322 19.5 States 322 19.6 Transitions 324 19.7 Events 325 19.8 What we have learned 328 20 Advanced statecharts 331 20.1 Chapter roadmap 331 20.2 Composite states 333 20.3 Sequential composite states 333 20.4 Concurrent composite states 335 20.5 Submachine communication 338 20.6 History 341 20.7 Submachine state 343 20.8 What we have learned 345 Part 5 Implementation 347 21 The implementation workflow 349 21.1 plementation workflow 350 21.3 Model trace relationships 351 21.4 Implementation workflow detail 352 21.5 Artefacts 353 21.6 What we have learned 353 22 Components 355 22.1 Chapter roadmap 355 22.2 What is a component? 356 22.3 Simple Java example 357 22.4 Enterprise JavaBean example 360 22.5 What we have learned 363 23 Deployment 364 23.1 Chapter roadmap 364 23.2 The deployment diagram 365 23.3 Deployment diagram syntax 366 23.4 Enterprise JavaBean example 368 23.5 What we have learned 370 Appendix 1: Example use case model 373 Appendix 2: XML and use cases 379 Bibliography 381 Index 383
by "Nielsen BookData"
