book

Object-Oriented Design Heuristics

by Arthur J. Riel

April 1996

Intermediate to advanced

400 pages

9h 31m

English

Addison-Wesley Professional

Read now

Unlock full access

Dedication
1.1. Revolutionists, Evolutionists, and the Object-Oriented Paradigm1.2. Accidental Versus Essential Complexity à la Frederick Brooks1.3. The Waterfall Model1.4. The Iterative Model1.5. Same- Versus Different-Language Prototyping1.6. Software Reusability1.7. Corporate Hierarchies of Good DesignersGlossary of Terms
2.1. Introduction to Classes and ObjectsHeuristic 2.12.2. Messages and MethodsHeuristic 2.2Heuristic 2.3Heuristic 2.4Heuristic 2.5Heuristic 2.62.3. Class Coupling and CohesionHeuristic 2.7Heuristic 2.8Heuristic 2.9Heuristic 2.102.4. Dynamic Semantics2.5. Abstract Classes2.6. Roles Versus ClassesHeuristic 2.11Glossary of TermsSummary of Heuristics
3.1. Differences in Application Topologies3.2. When the Action-Oriented Paradigm Goes Right3.3. The God Class Problem (Behavioral Form)Heuristic 3.1Heuristic 3.2Heuristic 3.3Heuristic 3.4Heuristic 3.53.4. Another Example of Poor System Intelligence DistributionHeuristic 3.63.5. The God Class Problem (Data Form)3.6. The Proliferation of Classes ProblemHeuristic 3.7Heuristic 3.8Heuristic 3.93.7. The Role of Agent ClassesHeuristic 3.103.8. Examining the Use of Separate Entity and Controller ClassesGlossary of TermsSummary of Heuristics
4.1. Introduction to Class and Object Relationships4.2. The Uses Relationship4.3. Six Different Ways to Implement the Uses Relationship4.4. Heuristics for the Uses RelationshipHeuristic 4.14.5. Refining the Amount of Collaboration Between Two ClassesHeuristic 4.2Heuristic 4.3Heuristic 4.44.6. The Containment RelationshipHeuristic 4.5Heuristic 4.6Heuristic 4.7Heuristic 4.84.7. Semantic Constraints Between ClassesHeuristic 4.9Heuristic 4.10Heuristic 4.11Heuristic 4.124.8. Attributes Versus Contained Classes4.9. More Containment HeuristicsHeuristic 4.13Heuristics 4.144.10. A Relationship Between Uses and Containment?4.11. Containment by Value Versus Containment by ReferenceGlossary of TermsSummary of Heuristics
5.1. Introduction to the Inheritance Relationship5.2. Overriding Base Class Methods in Derived ClassesHeuristic 5.1Heuristic 5.25.3. The Use of the Protected Section of a Base ClassHeuristic 5.35.4. The Width and Depth of Inheritance HierarchiesHeuristic 5.4Heuristic 5.55.5. Private, Protected, and Public Inheritance à la C+ +5.6. A Real-World Example of Specialization5.7. Heuristics That Trade Off Design Complexity and FlexibilityHeuristic 5.6Heuristic 5.75.8. A Real-World Example of GeneralizationHeuristic 5.85.9. The Mechanism of PolymorphismHeuristic 5.9Heuristic 5.10Heuristic 5.11Heuristic 5.125.10. A Problem with the Use of Inheritance as a Reusability Mechanism5.11. An Inheritance Solution to an Interrupt-Driven Architecture5.12. Inheritance Hierarchies Versus AttributesHeuristic 5.135.13. The Confusion of the Need for Inheritance Versus an Object's Dynamic SemanticsHeuristic 5.145.14. Using Inheritance to Hide the Representation of a Class5.15. Mistaking Objects for Derived ClassesHeuristic 5.155.16. Mistaking Object Generalization for the Need to Build Classes at RuntimeHeuristic 5.165.17. The Attempt to NOP a Base Class Method in Its Derived Class(es)Heuristic 5.175.18. The Implementation of Optional Parts of ObjectsHeuristic 5.185.19. A Problem with No Optimal Solution5.20. Reusing Components Versus Reusing FrameworksHeuristic 5.19GlossarySummary of Heuristics
6.1. Introduction to Multiple InheritanceHeuristic 6.16.2. The Common Misuse of Multiple InheritanceHeuristic 6.2Heuristic 6.36.3. A Valid Use of Multiple Inheritance6.4. Accidental Complexity In Languages That Do Not Support Multiple Inheritance6.5. Frameworks That Incorporate Multiple Inheritance6.6. The Use of Multiple Inheritance in the Design of Mixins6.7. DAG Multiple Inheritance6.8. Accidental DAG Multiple Inheritance via Poor Implementation of Optional ContainmentGlossaryHeuristics Summary
7.1. Introduction to Association7.2. Associations Implemented Through a Referential Attribute7.3. Association Implemented Through a Third-Party Class7.4. Deciding Between a Containment and an Association RelationshipHeuristic 7.1GlossaryHeuristics Summary

8.1. Introduction to Class-Specific Versus Object-Specific Data and BehaviorHeuristic 8.18.2. Using Metaclasses to Capture Class-Specific Data and Behavior8.3. Using Language-Level Keywords to Implement Class-Versus Object-Specific Data and Behavior8.4. Metaclasses à la C++8.5. A Useful Abstract Class That Is Not a Base Class?GlossaryHeuristics Summary
9.1. The Role of Logical and Physical Object-Oriented DesignHeuristic 9.19.2. The Construction of Object-Oriented Wrappers9.3. Persistence in an Object-Oriented System9.4. Memory Management Issues in an Object-Oriented Application9.5. Minimal Public Interfaces for Reusable ComponentsA Minimal Public Interface for All Reusable ClassesConstructor.Destructor.Copying Objects.Assigning Objects.Equality Testing.Print.Parse.Self-Test.9.6. Implementing Safe Shallow CopiesHeuristic 9.29.7. Concurrent Object-Oriented Programming9.8. Implementing Object-Oriented Designs in Nonobject-Oriented LanguagesOverloaded Functions.Class/Object.Data Hiding.Inheritance.Polymorphism.GlossarySummary of Heuristics
10.1. Heuristics Versus PatternsThe Broadcast PatternSource Pattern.Motivating Heuristic.Rationale.Target Pattern.10.2. Transitivity Among Design Transformation PatternsThe Interrupt PatternSource Pattern.Motivating HeuristicRationale.Target Pattern.The Interrupt-Polling PatternSource Pattern.Motivating Heuristic.Rationale.Target Pattern.10.3. The Reflexive Property of Design Transformation PatternsThe Generalization PatternSource Pattern.Motivating Heuristic.Rationale.Target Pattern.The Specialization PatternSource Pattern.Motivating Heuristic.Rationale.Target Pattern.10.4. Other Design Transformation PatternsThe Inverted Inheritance PatternSource Pattern.Motivating Heuristic.Rationale.Target Pattern.The Lexical Scope PatternSource Pattern.Motivational Heuristic.Rationale.Target Pattern.The One-Instance PatternSource Pattern.Motivational Heuristic.Rationale.Target Pattern.The Data-Hiding PatternSource Pattern.Motivating Heuristic.Rationale.Target Pattern.10.5. Future Research
11.1. The ATM ProblemThe ATM System Requirement Specification11.2. Choosing a Methodology11.3. A First Attempt at Producing an Object Model for the ATM11.4. Adding Behavior to Our Object Model11.5. Explicit Case Analysis Due to Accidental Complexity11.6. Messaging Objects in Different Address Spaces11.7. The Processing of the Transaction11.8. Returning to the Domain of the ATM11.9. Other Miscellaneous Issues11.10. Conclusion
Chapter 2 Classes and Objects: The Building Blocks of the Object-Oriented ParadigmChapter 3 Topologies of Action-Oriented Versus Object-Oriented ApplicationsChapter 4 The Relationships Between Classes and ObjectsChapter 5 The Inheritance RelationshipChapter 6 Multiple InheritanceChapter 7 The Association RelationshipChapter 8 Class-Specific Data and BehaviorChapter 9 Physical Object-Oriented Design
Leak #1Example Code for Leak #1Leak #2Example Code for Leak #2Leak #3Example Code for Leak #3Leak #4Example Code for Leak #4Leak #5Example Code for Leak #5Leak #6Example Code for Leak #6Leak #7Returning a Reference to a Stack ObjectReturning an Internal Static Object ReferenceReturning a Memory Leaking Dynamically Allocated ObjectCorrect Method for Leak #7Leak #8Code Example for Memory Leakage #8
Selected C++ Example #2Selected C++ Example #4Selected C++ Example #5Selected C++ Example #9Selected C++ Example #10Selected C++ Example #15Selected C++ Example #17Selected C++ Example #18Selected C++ Example #19Selected C++ Example #20Selected C++ Example #21The ATM Side of the ApplicationThe Atm.hpp FileThe Atm.cpp FileThe Bank Side of the ApplicationThe Bank.hpp FileThe Bank.cpp FileThe Common ClassesThe Trans.hpp FileThe Trans.cpp FileThe Network.hpp FileThe Network.cpp File

Content preview from Object-Oriented Design Heuristics

Appendix A. Heuristics Summary

Chapter 2 Classes and Objects: The Building Blocks of the Object-Oriented Paradigm

Heuristic 2.1. All data should be hidden within its class.

Heuristic 2.2. Users of a class must be dependent on its public interface, but a class should not be dependent on its users.

Heuristic 2.3. Minimize the number of messages in the protocol of a class.

Heuristic 2.4. Implement a minimal public interface that all classes understand [e.g., operations such as copy (deep versus shallow), equality testing, pretty printing, parsing from an ASCII description, etc.].

Heuristic 2.5. Do not put implementation details such as common-code private functions into the public interface of a class.

Heuristic 2.6. Do not clutter the public interface ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Start your free trial

Design Patterns Explained: A New Perspective on Object-Oriented Design, Second Edition

Alan Shalloway, James R. Trott

API Design Patterns

John J. Geewax

Refactoring to Patterns

Joshua Kerievsky

Micro Frontends in Action

Michael Geers

Publisher Resources

ISBN: 020163385XPurchase book