OBJECT ORIENTED ANALYSIS AND DESIGN WITH UML PATTERNS
1 INTRODUCTION 11 WHAT IS THE OBJECT-ORIENTED PARADIGM? 111 WHAT MAKES THE OBJECT-ORIENTED APPROACH PREFERABLE? 112 OBJECT-ORIENTED SOFTWARE DEVELOPMENT 12 KEY CONCEPTS OF OBJECT-ORIENTED DESIGN 13 OTHER RELATED CONCEPTS 131 MODULAR DESIGN AND ENCAPSULATION 132 COHESION AND COUPLING 133 MODIFIABILITY AND TESTABILITY 134 CODE SECURITY 14 BENEFITS OF THE PARADIGM 15 DEALING WITH DRAWBACKS OF THE PARADIGM 151 REDUCED PERFORMANCE 152 COMPLEXITY OF THE SYSTEM 153 LEARNING THE OBJECT-ORIENTED PARADIGM 16 HISTORY 17 DISCUSSION AND FURTHER READING 2 BASICS OF OBJECT-ORIENTED PROGRAMMING 21 THE BASICS 22 IMPLEMENTING CLASSES 221 CONSTRUCTORS 222 PRINTING AN OBJECT 223 SHARING DATA ACROSS ALL OBJECTS 23 CREATING AND WORKING WITH RELATED CLASSES 24 DEFINING AND WORKING WITH COLLECTIONS 241 CREATING A COLLECTION CLASS 242 IMPLEMENTATION OF STUDENTLINKEDLIST 25 INTERFACES 251 WHY USE INTERFACES? 252 IMPROVING REUSE WITH AN INTERFACE 253 ARRAY IMPLEMENTATION OF LISTS 26 ABSTRACT CLASSES 27 DEALING WITH RUN-TIME ERRORS 28 INHERITANCE 281 AN EXAMPLE OF A HIERARCHY 282 INHERITING FROM AN INTERFACE 283 POLYMORPHISM AND DYNAMIC BINDING 284 PROTECTED FIELDS AND METHODS 29 DESIGN PATTERNS 291 ITERATING OVER THE ITEMS IN A LIST 292 NEED FOR A COMMON MECHANISM 293 THE ITERATOR PATTERN 210 RUN-TIME TYPE IDENTIFICATION 211 THE OBJECT CLASS 2111 USING OBJECT AS A GENERAL REFERENCE 2112 UTILITY METHODS PROVIDED BY OBJECT 2113 METHODS FOR SYSTEM SUPPORT 212 AN INTRODUCTION TO GENERICS IN JAVA 213 DISCUSSION AND FURTHER READING 3 MODELING OBJECT-ORIENTED SYSTEMS 31 A FIRST EXAMPLE 32 CHOOSING THE DIAGRAMS TO DESCRIBE AN OBJECT-ORIENTED SYSTEM 321 BUILDING MODELS TO REPRESENT THE SYSTEM 322 DIAGRAMS SUPPORTED BY UML 33 BUILDING A USER INTERFACE MODEL 331 REQUIREMENTS FOR AN ATM SYSTEM 332 DETAILED USE CASES FOR THE ATM 333 A SIMPLE INTERFACE FOR COURSE REGISTRATION 34 BUILDING A LOGICAL MODEL 341 A LOGICAL MODEL FOR THE ATM SYSTEM 342 A LOGICAL MODEL FOR A COLLEGE REGISTRATION SYSTEM 343 LOGICAL MODELS IN VARIOUS STAGES OF DEVELOPMENT 35 MODELING THE INTERACTION BETWEEN ENTITIES 351 SEQUENCE DIAGRAMS 352 COMMUNICATION DIAGRAMS 36 MODELING THE BEHAVIOR OF A SYSTEM 361 STATE TRANSITION DIAGRAMS 362 ACTIVITY DIAGRAMS 37 DISCUSSION 371 WHICH UML DIAGRAMS SHOULD WE CHOOSE? 4 ANALYZING A SYSTEM 41 GATHERING THE REQUIREMENTS 411 THE LIBRARY CASE STUDY 42 BUILDING THE USER INTERACTION MODEL 421 USE CASE ANALYSIS 422 DETAILED USE CASES FOR THE LIBRARY SYSTEM 43 DEFINING CONCEPTUAL CLASSES AND RELATIONSHIPS 431 CONCEPTUAL CLASSES FOR THE LIBRARY SYSTEM 432 IDENTIFYING THE RELATIONSHIPS BETWEEN THE CLASSES 44 USING THE KNOWLEDGE OF THE DOMAIN 45 DISCUSSION AND FURTHER READING 5 DESIGNING A SYSTEM 51 INITIATING THE DESIGN PROCESS 511 THE MAJOR SUBSYSTEMS 512 IDENTIFYING THE SOFTWARE CLASSES 52 ASSIGNING RESPONSIBILITIES TO THE CLASSES 521 ACTIONS THAT ADD NEW ENTITIES (POPULATING THE SYSTEM) 522 ADDING/REMOVING THE RELATIONSHIP BETWEEN EXISTING ENTITIES 523 ACTIONS THAT REMOVE OBJECTS 524 ACTIONS THAT INVOLVE QUERIES 53 DESIGNING THE CLASSES 531 DESIGNING THE MEMBER AND BOOK CLASSES 532 BUILDING THE COLLECTION CLASSES 533 DESIGNING THE HOLD AND TRANSACTION CLASSES 534 DESIGNING THE LIBRARY CLASS 535 CONSTRUCTING THE USER INTERFACE 54 DESIGNING FOR SAFETY AND SECURITY 541 ENSURING THAT THE DATA IS NOT INCONSISTENT 542 PREVENTING UNAUTHORIZED OBJECTS FROM MAKING DATA UPDATES 543 PREVENTING UNAUTHORIZED ACCESS THROUGH EXPORTED OBJECTS 55 EVALUATING THE QUALITY OF THE SOFTWARE DESIGN 551 A NEW REQUIREMENT: CHARGING FINES FOR OVERDUE BOOKS 552 THE INITIAL DESIGN 553 EVALUATING AND IMPROVING THE SOLUTION 56 DISCUSSION AND FURTHER READING 561 CONCEPTUAL CLASSES AND SOFTWARE CLASSES 562 THE SINGLE RESPONSIBILITY PRINCIPLE 563 THE INTERFACE SEGREGATION PRINCIPLE 564 RECOGNIZING BAD SMELLS AND DESIGN FLAWS IN OBJECT-ORIENTED PROGRAMS 565 BUILDING A COMMERCIALLY ACCEPTABLE SYSTEM 566 FURTHER READING 6 IMPLEMENTING A SYSTEM 61 ORGANIZATION OF USERINTERFACE AND LIBRARY 611 AVOIDING THE CREATION OF MULTIPLE LIBRARIES 612 STRUCTURE OF LIBRARY 62 POPULATING THE DATABASE 621 ADDING A MEMBER 622 CREATION OF A MEMBER OBJECT 623 MAINTAINING THE COLLECTION OF MEMBER OBJECTS 624 USING PRE-EXISTING COLLECTION CLASSES 625 IMPLEMENTING CATALOG AND MEMBERLIST 63 MODIFYING RELATIONSHIPS BETWEEN OBJECTS 631 ISSUING BOOKS 632 PLACING A HOLD 633 MAINTAINING THE COLLECTION OF HOLDS 634 RETURNING BOOKS 635 PROCESS HOLDS 636 RENEWING BOOKS 64 REMOVING OBJECTS 641 REMOVING A HOLD 642 REMOVING BOOKS 65 DISPLAYING TRANSACTIONS 651 THE FILTERED ITERATOR 66 OTHER REQUIREMENTS 661 SAVING AND RETRIEVING DATA 662 PROTECTING THE DATA EVEN FURTHER 67 DISCUSSION AND FURTHER READING 671 SUMMARY OF THE IMPLEMENTATION 672 CONCEPTUAL, SOFTWARE, AND IMPLEMENTATION CLASSES 673 BUILDING A COMMERCIALLY ACCEPTABLE SYSTEM 7 DESIGNING FOR REUSE 71 REUSING THROUGH GENERIC IMPLEMENTATIONS 711 DESIGNING A GENERIC COLLECTION CLASS 712 A CAVEAT ON USING THE EQUALS() METHOD 713 A DIFFERENT APPROACH 714 INSTANTIATING CATALOG AND MEMBERLIST 72 USING REUSABLE TYPES TO OBTAIN REUSABLE IMPLEMENTATIONS 721 A REUSABLE SORTING ALGORITHM 73 BUILDING AN INHERITANCE HIERARCHY 731 THE SITUATION WITHOUT INHERITANCE 732 USING INHERITANCE TO IMPROVE THE DESIGN 733 INVOKING THE CONSTRUCTORS 734 DISTRIBUTING THE RESPONSIBILITIES 735 FACTORING RESPONSIBILITIES ACROSS THE HIERARCHY 74 COMBINING INHERITANCE AND COMPOSITION 741 THE JAVA THREAD CLASS 742 REUSING THE PERSON CLASS IN FACULTY AND STUDENT 75 THE IMPORTANCE OF SUBSTITUTABILITY FOR REUSE 751 EXTENDING A SIMPLE COUNTER 752 INHERITING FROM AN ABSTRACT SUPERCLASS 753 UPGRADING TO A GENERALIZED COUNTER 754 DEFINING, PROTECTING, AND PROGRAMMING TO AN ABSTRACTION 76 DISCUSSION AND FURTHER READING 761 LANGUAGE MECHANISMS FOR REUSE 762 PROGRAMMING TO AN ABSTRACTION 763 DEALING WITH VARIABILITY 764 PRINCIPLES OF CLASS DESIGN 8 MODELING WITH FINITE STATE MACHINES 81 A SIMPLE EXAMPLE 811 HOW TO APPROACH THIS PROBLEM 82 REQUIREMENTS ANALYSIS USING FINITE STATE MODELING 821 DEFINING THE FSM FOR THE MICROWAVE 822 STATE MINIMIZATION 83 A FIRST SOLUTION TO THE MICROWAVE PROBLEM 831 COMPLETING THE ANALYSIS 832 DESIGNING THE SYSTEM 833 THE IMPLEMENTATION CLASSES 834 DISPLAY IMPLEMENTATIONS 84 CRITIQUING THE SIMPLE SOLUTION 841 COMPLEXITY IN MICROWAVE 842 COMMUNICATION AMONG OBJECTS 85 USING THE STATE PATTERN 851 CREATING THE STATE HIERARCHY 852 TRANSITIONING BETWEEN STATES 853 THE STATE CLASSES 86 COMMUNICATING THE TIMING EVENTS 861 THE OBSERVER PATTERN 862 GENERATING AND HANDLING TIMING EVENTS 87 REPLACING EVENT CONDITIONALS WITH POLYMORPHISM 871 CODE ORGANIZATION 88 EMPLOYING THE FSM MODEL FOR OTHER TYPES OF APPLICATIONS 881 GRAPHICAL USER INTERFACES (GUIS) 882 MODELING A NETWORK PROTOCOL 89 DISCUSSION AND FURTHER READING 891 IMPLEMENTING THE STATE PATTERN 892 FEATURES OF THE STATE PATTERN 893 CONSEQUENCES OF OBSERVER 894 RECOGNIZING AND PROCESSING EXTERNAL EVENTS 9 INTERACTIVE SYSTEMS AND THE MODEL–VIEW–CONTROLLER ARCHITECTURE 91 THE MODEL–VIEW–CONTROLLER ARCHITECTURAL PATTERN 911 EXAMPLES 912 IMPLEMENTATION 913 BENEFITS 92 ANALYZING A SIMPLE DRAWING PROGRAM 921 SPECIFYING THE REQUIREMENTS 922 DEFINING THE USER INTERFACE 923 META OPERATIONS 93 DETAILED USE CASES FOR THE DRAWING OPERATIONS 931 DRAWING THE SHAPES 932 SHAPE MANIPULATION OPERATIONS 94 DESIGNING THE DRAWING PROGRAM 941 SHAPE REPRESENTATION 942 INTERACTION BETWEEN MODEL, VIEW, AND CONTROLLER 943 INTERFACE-INDEPENDENT CONTROLLER 944 INTERFACE-INDEPENDENT VIEW 945 MODEL–VIEW SEPARATION 946 DESIGN TO SUPPORT UNDO AND REDO 947 GROUPING, UNGROUPING, AND SHAPE COLLECTIONS 948 SELECTING, DELETION, AND MOVING 949 CONTROLLER STRUCTURE 9410 SEQUENCE DIAGRAMS FOR SHAPE MANIPULATION 9411 DETAILS OF CLASSES 9412 FINAL DETAILS OF VIEW DESIGN 9413 GUI DESIGN 95 IMPLEMENTATION 951 STARTING THE PROGRAM 952 DRAWING A LINE 953 SELECTING SHAPES 954 GROUPING SHAPES 955 MOVING SHAPES 96 PATTERN-BASED SOLUTIONS 961 EXAMPLES OF ARCHITECTURAL PATTERNS 97 DISCUSSION AND CONCLUSION 971 ADAPTING TO DISTRIBUTED SYSTEMS 972 INTERACTION BETWEEN THE GUI AND THE MVC SUBSYSTEMS 973 GUI FRAMEWORKS 974 THE SPACE OVERHEAD FOR THE COMMAND PATTERN 975 BUILDING THE BACK END USING THE STATE PATTERN 976 HOW TO STORE THE SHAPES 977 EXERCISING CAUTION WHEN ALLOWING UNDO 10 A DEEPER LOOK INTO INHERITANCE 101 APPLICATIONS OF INHERITANCE 1011 RESTRICTING BEHAVIORS AND PROPERTIES 1012 ABSTRACT SUPERCLASS 1013 ADDING FEATURES 1014 HIDING FEATURES OF THE SUPERCLASS 1015 COMBINING STRUCTURAL AND TYPE INHERITANCE 102 INHERITANCE: SOME LIMITATIONS AND CAVEATS 1021 DEEP HIERARCHIES 1022 LACK OF MULTIPLE INHERITANCE 1023 EXPOSED SUPERCLASS FEATURES 1024 CHANGES IN THE SUPERCLASS 1025 CREATING FALSE SUBTYPES 1026 HOW TO VERIFY SUBSTITUTABILITY 103 WORKING WITH INHERITANCE 1031 EMPLOYING CREATIONAL PATTERNS 1032 INTRODUCING A PARALLEL HIERARCHY 1033 ADDING NEW FUNCTIONALITY TO A HIERARCHY 104 TRANSMITTING COMPLEX PROPERTIES USING INHERITANCE 1041 CREATING A SINGLETON HIERARCHY 1042 INHERITING THE PROPERTY OF SELF-REPLICATION 105 USING LSP TO VERIFY SUBSTITUTABILITY* 1051 THE RELATIONSHIP BETWEEN BAG, SET, AND QUEUE 1052 GENERIC SUBCLASSING: QUEUE OF STRING AND QUEUE OF OBJECT 1053 USING QUEUE OF OBJECT IN LIEU OF QUEUE OF STRING 1054 WHY IS A PIXEL OBJECT NOT A SOLIDRECTANGLE? 1055 LSP IN PROGRAMMING LANGUAGES 106 MULTIPLE INHERITANCE* 1061 MECHANISMS FOR RESOLVING CONFLICTS 1062 REPEATED INHERITANCE 1063 MULTIPLE INHERITANCE IN JAVA 107 DISCUSSION AND FURTHER READING 1071 RELATING GENERICITY AND INHERITANCE 1072 USING THE VISITOR PATTERN 1073 PERFORMANCE ISSUES FOR SINGLE VERSUS DOUBLE DISPATCH 1074 ENSURING THE SAFETY OF REUSE