最 低 价：￥78.00
| CRAIG LARMAN serves as Director of Process and Methodology at Valtech, a leading international e-business consulting group. He is known throughout the international software community as an expert in object technologies, patterns, the UML, modeling, and iterative development. Since the 1980s, Larman has been helping people learn objects and iterative development, having personally guided thousands of developers. He is also the co-author of Java 2.. << 查看详细 |
| foreword xv preface xvii part i introduction 1 object-oriented analysis and design 3 applying uml and patterns in ooa/d 3 assigning responsibilities 6 what is analysis and design? 6 what is object-oriented analysis and design? 7 an example 7 the uml 10 further readings 11 2 iterative development and the unified process 13 the most important up idea: iterative development 14 additional up best practices and concepts 18 the up phases and schedule-oriented terms 19 the up disciplines (was workfiows) 20 process customization and the development case 23 the agile up 24 the sequential "waterfall" lifecycle 25 you know you didn't understand the up when... 26 .further readings 26 3 case study: the nextgen pos system 29 the nextgen pos system 29 architectural layers and case study emphasis 30 the book's strategy: iterative learning and development 31 part ii inception 4 inception 35 inception: an analogy 36 inception may be very brief 36 what artifacts may start in inception? 37 you know you didn't understand inception when... 38 5 understanding requirements 41 types of requirements 42 further readings 43 6 use-case model: writing requirements in context 45 goals and stories 46 background 46 use cases and adding value 47 use cases and functional requirements 48 use case types and formats 49 fully dressed example: process sale 50 explaining the sections 54 goals and scope of a use case 59 finding primary actors, goals, and use cases 63 congratulations: use cases have been written, and are imperfect 67 write use cases in an essential ui-free style 68 actors 70 use case diagrams 71 requirements in context and low-level feature lists 73 use cases are not object-oriented 75 use cases within the up 75 case study: use cases in the nextgen inception phase 79 further readings 79 up artifacts and process context 81 7 identifying other requirements 83 nextgen pos examples 84 nextgen example: (partial) supplementary specification 84 commentary: supplementary specification 88 nextgen example: (partial) vision 91 commentary: vision 93 nextgen example: a (partial) glossary 98 commentary: glossary (data dictionary) 99 reliable specifications: an oxymoron? 100 online artifacts at the project website 101 not much uml during inception? 101 other requirement artifacts within the up 101 further readings 104 up artifacts and process context 105 8 from inception to elaboration 107 checkpoint: what happened in inception? 108 on to elaboration 109 planning the next iteration 110 iteration i requirements and emphasis: fundamental ooa/d skills 112 what artifacts may start in elaboration? 113 you know you didn't understand elaboration when... 114 part iii elaboration iteration 1 9 use-case model: drawing system sequence diagrams 117 system behavior 118 system sequence diagrams 118 example of an ssd 119 inter-system ssds 120 ssds and use cases 120 system events and the system boundary 120 naming system events and operations 121 showing use case text 122 ssds and the glossary 122 ssds within the up 123 further readings 124 up artifacts 125 10 domain model: visualizing concepts 127 domain models 128 conceptual class identification 132 candidate conceptual classes for the sales domain 136 domain modeling guidelines 137 resolving similar conceptual classes--register vs. "post" 139 modeling the unreal world 140 specification or description conceptual classes 140 uml notation, models, and methods: multiple perspectives 144 lowering the representational gap 146 example: the nextgen pos domain model 148 domain models within the up 148 further readings 150 up artifacts 151 11 domain model: adding associations 153 associations 153 the umlassociation notation 154 finding associations--common associations list 155 association guidelines 157 roles 157 how detailed should associations be? 159 naming associations 160 multiple associations between two types 161 associations and hnplementation 161 nextgen pos domain modelassociations 162 nextgen pos domain model 163 12 domain model: adding attributes 167 attributes 167 uml attribute notation 168 valid attribute types 168 non-primitive data type classes 170 design creep: no attributes as foreign keys 172 modeling attribute quantities and units 173 attributes in the nextgen domain model 174 multiplicity from saleslineitem to item 175 domain model conclusion 175 13 use-case model: adding detail with operation contracts 177 contracts 177 example contract: enteritem 178 contract sections 179 postconditions 179 discussion--enteritem postconditions 182 writing contracts leads to domain model updates 183 when are contracts useful? contracts vs. use cases? 183 guidelines: contracts 184 nextgen pos example: contracts 185 changes to the domain model 186 contracts, operations, and the uml 186 operation contracts within the up 188 further readings 191 14 from requirements to design in this iteration 193 iteratively do the right thing, do the thing right 193 didn't that take weeks to do? no, not exactly. 194 on to object design 194 15 interaction diagram notation 197 sequence and collaboration diagrams 198 example collaboration diagram: makepayment 199 example sequence diagram: makepayment 200 interaction diagrams are valuable 200 common interaction diagram notation 201 basic collaboration diagram notation 202 basic sequence diagram notation 208 16 grasp: designing objects with responsibilities 215 responsibilities and methods 216 responsibilities and interaction diagrams 217 patterns 218 grasp: patterns of general principles in assigning responsibilities 219 the uml class diagram notation 220 information expert (or expert) 221 creator 226 low coupling 229 high cohesion 232 controller 237 object design and crc cards 245 further readings 246 17 design model: use-case realizations with grasp patterns 247 use-case realizations 248 artifact comments 249 use-case realizations for the nextgen iteration 252 object design: makenewsale 253 object design: enteritem 255 object design: endsale 260 object design: makepayment 264 object design: startup 269 connecting the ui layer to the domain layer 273 use-case realizations within the up 276 summary 278 18 design model: determining visibility 279 visibility between objects 279 visibility 280 illustrating visibility in the uml 284 19 design model: creating design class diagrams 285 when to create dcds 285 example dcd 286 dcd and up terminology 286 domain model vs. design model classes 287 creating a nextgen pos dcd 287 notation for member details 296 dcds, drawing, and case tools 298 dcds within the up 298 up artifacts 299 20 implementation model: mapping designs to code 301 programming and the development process 302 mapping designs to code 304 creating class definitions from dcds 304 creating methods from interaction diagrams 307 container/collection classes in code 309 exceptions and error handling 309 defining the sale-makelineitem method 310 order of implementation 311 test-first programming 311 summary of mapping designs to code 313 introduction to the program solution 313 part iv elaboration iteration 2 21 iteration 2 and its requirements 319 iteration 2 emphasis: object design and patterns 319 from iteration i to 2 319 iteration 2 requirements 321 refinement of analysis-oriented artifacts in this iteration 322 22 grasp: more patterns for assigning responsibilities 325 polymorphism 326 pure fabrication 329 indirection 332 protected variations 334 23 designing use-case realizations with gof design patterns 341 adapter (gof) 342 "analysis" discoveries during design: domain model 345 factory (gof) 346 singleton (gof) 348 conclusion of the external services with varying interfaces problem 352 strategy (gof) 353 composite (gof) and other design principles 358 facade (gof) 368 observer/publish-subscribe/delegation event model (gof) 372 conclusion 380 further readings 380 part v elaboration iteration 3 24 iteration 3 and its requirements 383 iteration 3 requirements 383 iteration 3 emphasis 383 25 relating use cases 385 the include relationship 386 terminology: concrete, abstract, base, and addition use cases 388 the extend relationship 389 the generalize relationship 390 use case diagrams 391 26 modeling generalization 393 new concepts for the domain model 393 generalization 396 defining conceptual superclasses and subclasses 397 when to define a conceptual subclass 400 when to define a conceptual superclass 403 nextgen pos conceptual class hierarchies 403 abstract conceptual classes 406 modeling changing states 408 class hierarchies and inheritance in software 409 27 refining the domain model 411 association classes 411 aggregation and composition 414 time intervals and product prices--fixing an iteration 1 "error" 418 association role names 419 roles as concepts vs. roles in associations 420 derived elements 421 qualified associations 422 reflexive associations 423 ordered elements 423 using packages to organize the domain model 423 28 adding new ssds and contracts 431 new system sequence diagrams 431 new system operations 433 new system operation contracts 434 29 modeling behavior in statechart diagrams 437 events, states, and transitions 437 statechart diagrams 438 statechart diagrams in the up? 439 use case statechart diagrams 439 use case statechart diagrams for the pos application 441 classes that benefit from statechart diagrams 441 illustrating external and interval events 443 additional statechart diagram notation 444 further readings 446 30 designing the logical architecture with patterns 447 software architecture 448 architectural pattern: layers 450 the model-view separation principle 471 further readings 474 31 organizing the design and implementation model packages 475 package organization guidelines 476 more uml package notation 482 further readings 483 32 introduction to architectural analysis and the sad 485 architectural analysis 486 types and views of architecture 488 the science: identification and analysis of architectural factors 488 example: partial nextgen pos architectural factor table 491 the art: resolution of architectural factors 493 summary of themes in architectural analysis 499 architectural analysis within the up 500 further readings 505 33 designing more use-case realizations with objects and patterns 507 failover to local services; performance with local caching 507 handling failure 512 failover to local services with a proxy (gof) 519 designing for non-functional or quality requirements 523 accessing external physical devices with adapters; buy vs. build 523 abstract factory (gof) for families of related objects 525 handling payments with polymorphism and do it myself 528 conclusion 535 34 designing a persistence framework with patterns 537 the problem: persistent objects 538 the solution: a persistence service from a persistence framework 538 frameworks 539 requirements for the persistence service and framework 540 key ideas 540 pattern: representing objects as tables 541 uml data modeling profile 541 pattern: object identifier 542 accessing a persistence service with a facade 543 mapping objects: database mapper or database broker pattern 543 framework design with the template method pattern 546 materialization with the template method pattern 546 configuring mappers with a mapperfactory 552 pattern: cache management 552 consolidating and hiding sql statements in one class 553 transactional states and the state pattern 554 designing a transaction with the command pattern 556 lazy materialization with a virtual proxy 559 how- to represent relationships in tables 562 persistentobject superclass and separation of concerns 563 unresolved issues 564 part vi special topics 35 on drawing and tools 567 on speculative design and visual thinking 567 suggestions for uml drawing within the development process 568 tools and sample features 571 example two 573 36 introduction to iterative planning and project issues 575 ranking requirements 576 ranking project risks 579 adaptive vs. predictive planning 579 phase and iteration plans 581 iteration plan: what to do in the next iteration? 582 requirements tracking across iterations 583 the (in)validity of early estimates 585 organizing project artifacts 585 some team iteration scheduling issues 586 you know you didn't understand planning in the up when... 588 further readings 588 37 comments on iterative development and the up 589 additional up best practices and concepts 589 the construction and transition phases 591 other interesting practices 592 motivations for timeboxing an iteration 593 the sequential "waterfall" lifecycle 593 usability engineering and user interface design 599 the up analysis model 599 the rup product 600 the challenge and myths of reuse 601 118 more uml notation 603 general notation 603 implementation diagrams 604 template (parameterized, generic} class 606 activity diagrams 607 bibliography 609 glossary 615 index 621 |
内容加载中，请稍后...
商品评论（0条）