1 / 11

GoF Sections 1.6-1.8

GoF Sections 1.6-1.8. Design Problems and Design Patterns. Warning – Reading this Book May Cause an Uncontrollable Urge to Redesign Everything. Don’t Read this Book Too Close to a Deadline! Decision Related Stress Results from having to decide whether to:

wcollins
Download Presentation

GoF Sections 1.6-1.8

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. GoF Sections 1.6-1.8 Design Problems and Design Patterns

  2. Warning – Reading this Book May Cause an Uncontrollable Urge to Redesign Everything • Don’t Read this Book Too Close to a Deadline! • Decision Related Stress • Results from having to decide whether to: • Explain to your boss why you redesigned the project a week before the ship date or • Finish a design you know isn’t right

  3. How Design Patterns Solve Design Problems • Find Appropriate Objects • Patterns bring a set of objects with them, helping ensure low-level objects and high-level abstractions are not overlooked • Determine Object Granularity • Patterns determine object granularity by specifying what types of objects are required for implementing the pattern • Specify Object Interfaces • Patterns describe what interfaces need to be supported and what kinds of data needs to be handled • Patterns describe relationships between interfaces and place requirements/constraints on classes and even other patterns

  4. How Design Patterns Solve Design Problems • Specify Object Implementations • Patterns give a blueprint for implementation by defining such things as class relationships (class diagrams), abstract vs. concrete classes and class vs. interface inheritance • Put Reuse Mechanisms to Work • Pattern definitions specify which reuse techniques (inheritance, composition, parameterized types) apply to the pattern

  5. How Design Patterns Solve Design Problems • Relate Run-Time and Compile-Time Structures • Patterns capture the distinction between run-time and compile-time structures that aren’t always clear when looking at code and data structures • Design for Change • Patterns anticipate change in certain areas of the system, thus incorporating flexibility to account for future changes without redesigning the system • The flexibility incorporated by patterns tends to generate reusable designs

  6. Patterns and Reuse • Patterns can make reuse easier in in a variety of systems with different reuse needs: • Applications (internal reuse) • Toolkits (code reuse) • Frameworks (design reuse)

  7. Causes of Redesign and Solutions Using Patterns • Explicit Class Specification • Avoid committing to a particular implementation by creating objects indirectly • Dependence on Specific Operations • Provide multiple ways for satisfying requests • Platform Dependence • Eliminate platform dependencies by separating abstractions from implementations • Implementation/Representation Dependence • Prevent changes from cascading thorough a design by hiding implementations and representations from clients (program to an interface, not an implementation)

  8. Causes of Redesign and Solutions Using Patterns • Algorithmic Dependencies • Decouple algorithms from objects by isolating algorithms and allowing it to be replaced independently • Tight Coupling • Eliminate coupling between classes to allow each class to be used (or reused) independently • Subclassing • Provide alternatives to subclassing, which can be expensive (during implementation as well as at run-time) • Inflexible Classes and Hierarchies • Provide ways of modifying classes when manipulation of the source code is problematic

  9. Selecting a Design Pattern • Six Approaches Noted by the Author • Consider how patterns solve design problems (section 1.6) • Scan Intent sections (section 1.4) • Study pattern interrelationships (figure 1.1) • Study patterns categorically (table 1.1) • Examine causes of redesign (pp 24,25) • Consider what needs to change (table 1.2)

  10. Selecting a Design Pattern • Additional Approaches • Beg, borrow or steal ideas from other people • Do it wrong, then fix it

  11. Using a Design Pattern • Seven Step Approach to Applying Patterns • Read the pattern to get an overview • Study the Structure, Participants and Collaborations sections • Study the sample code • Rename the participants to match the context • Define the classes • Create context-specific names for pattern operations • Implement the pattern operations • Consider How Not to Apply Patterns • Need to consider consequences; patterns are one tool in the toolbox, not a panacea

More Related