Table of Contents

< Free Open Study >



•	Table of Contents

Object-Oriented Design Heuristics
By Arthur J. Riel

Publisher	: Addison Wesley
Pub Date	: April 30, 1996
ISBN	: 0-201-63385-X
Pages	: 400
Slots	: 1

Acknowledgements

Chapter 1. The Motivation for Object-Oriented Programming

Section 1.1. Revolutionists, Evolutionists, and the Object-Oriented Paradigm

Section 1.2. Accidental Versus Essential Complexity à la Frederick Brooks

Section 1.3. The Waterfall Model

Section 1.4. The Iterative Model

Section 1.5. Same- Versus Different-Language Prototyping

Section 1.6. Software Reusability

Section 1.7. Corporate Hierarchies of Good Designers

Glossary of Terms

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

Section 2.1. Introduction to Classes and Objects

Section 2.2. Messages and Methods

Section 2.3. Class Coupling and Cohesion

Section 2.4. Dynamic Semantics

Section 2.5. Abstract Classes

Section 2.6. Roles Versus Classes

Glossary of Terms

Summary of Heuristics

Chapter 3. Topologies of Action-Oriented Versus Object-Oriented Applications

Section 3.1. Differences in Application Topologies

Section 3.2. When the Action-Oriented Paradigm Goes Right

Section 3.3. The God Class Problem (Behavioral Form)

Section 3.4. Another Example of Poor System Intelligence Distribution

Section 3.5. The God Class Problem (Data Form)

Section 3.6. The Proliferation of Classes Problem

Section 3.7. The Role of Agent Classes

Section 3.8. Examining the Use of Separate Entity and Controller Classes

Glossary of Terms

Summary of Heuristics

Chapter 4. The Relationships Between Classes and Objects

Section 4.1. Introduction to Class and Object Relationships

Section 4.2. The Uses Relationship

Section 4.3. Six Different Ways to Implement the Uses Relationship

Section 4.4. Heuristics for the Uses Relationship

Section 4.5. Refining the Amount of Collaboration Between Two Classes

Section 4.6. The Containment Relationship

Section 4.7. Semantic Constraints Between Classes

Section 4.8. Attributes Versus Contained Classes

Section 4.9. More Containment Heuristics

Section 4.10. A Relationship Between Uses and Containment?

Section 4.11. Containment by Value Versus Containment by Reference

Glossary of Terms

Summary of Heuristics

Chapter 5. The Inheritance Relationship

Section 5.1. Introduction to the Inheritance Relationship

Section 5.2. Overriding Base Class Methods in Derived Classes

Section 5.3. The Use of the Protected Section of a Base Class

Section 5.4. The Width and Depth of Inheritance Hierarchies

Section 5.5. Private, Protected, and Public Inheritance à la C+ +

Section 5.6. A Real-World Example of Specialization

Section 5.7. Heuristics That Trade Off Design Complexity and Flexibility

Section 5.8. A Real-World Example of Generalization

Section 5.9. The Mechanism of Polymorphism

Section 5.10. A Problem with the Use of Inheritance as a Reusability Mechanism

Section 5.11. An Inheritance Solution to an Interrupt-Driven Architecture

Section 5.12. Inheritance Hierarchies Versus Attributes

Section 5.13. The Confusion of the Need for Inheritance Versus an Object's Dynamic Semantics

Section 5.14. Using Inheritance to Hide the Representation of a Class

Section 5.15. Mistaking Objects for Derived Classes

Section 5.16. Mistaking Object Generalization for the Need to Build Classes at Runtime

Section 5.17. The Attempt to NOP a Base Class Method in Its Derived Class(es)

Section 5.18. The Implementation of Optional Parts of Objects

Section 5.19. A Problem with No Optimal Solution

Section 5.20. Reusing Components Versus Reusing Frameworks

Summary of Heuristics

Chapter 6. Multiple Inheritance

Section 6.1. Introduction to Multiple Inheritance

Section 6.2. The Common Misuse of Multiple Inheritance

Section 6.3. A Valid Use of Multiple Inheritance

Section 6.4. Accidental Complexity In Languages That Do Not Support Multiple Inheritance

Section 6.5. Frameworks That Incorporate Multiple Inheritance

Section 6.6. The Use of Multiple Inheritance in the Design of Mixins

Section 6.7. DAG Multiple Inheritance

Section 6.8. Accidental DAG Multiple Inheritance via Poor Implementation of Optional Containment

Heuristics Summary

Chapter 7. The Association Relationship

Section 7.1. Introduction to Association

Section 7.2. Associations Implemented Through a Referential Attribute

Section 7.3. Association Implemented Through a Third-Party Class

Section 7.4. Deciding Between a Containment and an Association Relationship

Heuristics Summary

Chapter 8. Class-Specific Data and Behavior

Section 8.1. Introduction to Class-Specific Versus Object-Specific Data and Behavior

Section 8.2. Using Metaclasses to Capture Class-Specific Data and Behavior

Section 8.3. Using Language-Level Keywords to Implement Class-Versus Object-Specific Data and Behavior

Section 8.4. Metaclasses à la C++

Section 8.5. A Useful Abstract Class That Is Not a Base Class?

Heuristics Summary

Chapter 9. Physical Object-Oriented Design

Section 9.1. The Role of Logical and Physical Object-Oriented Design

Section 9.2. The Construction of Object-Oriented Wrappers

Section 9.3. Persistence in an Object-Oriented System

Section 9.4. Memory Management Issues in an Object-Oriented Application

Section 9.5. Minimal Public Interfaces for Reusable Components

Section 9.6. Implementing Safe Shallow Copies

Section 9.7. Concurrent Object-Oriented Programming

Section 9.8. Implementing Object-Oriented Designs in Nonobject-Oriented Languages

Summary of Heuristics

Chapter 10. The Relationship Between Heuristics and Patterns

Section 10.1. Heuristics Versus Patterns

Section 10.2. Transitivity Among Design Transformation Patterns

Section 10.3. The Reflexive Property of Design Transformation Patterns

Section 10.4. Other Design Transformation Patterns

Section 10.5. Future Research

Chapter 11. The Use of Heuristics in Object-Oriented Design

Section 11.1. The ATM Problem

Section 11.2. Choosing a Methodology

Section 11.3. A First Attempt at Producing an Object Model for the ATM

Section 11.4. Adding Behavior to Our Object Model

Section 11.5. Explicit Case Analysis Due to Accidental Complexity

Section 11.6. Messaging Objects in Different Address Spaces

Section 11.7. The Processing of the Transaction

Section 11.8. Returning to the Domain of the ATM

Section 11.9. Other Miscellaneous Issues

Section 11.10. Conclusion

Appendix A. Heuristics Summary

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

Chapter 3 Topologies of Action-Oriented Versus Object-Oriented Applications

Chapter 4 The Relationships Between Classes and Objects

Chapter 5 The Inheritance Relationship

Chapter 6 Multiple Inheritance

Chapter 7 The Association Relationship

Chapter 8 Class-Specific Data and Behavior

Chapter 9 Physical Object-Oriented Design

Appendix B. The Prevention of Memory Leakage

Example Code for Leak #1

Example Code for Leak #2

Example Code for Leak #3

Example Code for Leak #4

Example Code for Leak #5

Example Code for Leak #6

Returning a Reference to a Stack Object

Returning an Internal Static Object Reference

Returning a Memory Leaking Dynamically Allocated Object

Correct Method for Leak #7

Code Example for Memory Leakage #8

Appendix C. Selected C++ Examples

Selected C++ Example #2

Selected C++ Example #4

Selected C++ Example #5

Selected C++ Example #9

Selected C++ Example #10

Selected C++ Example #15

Selected C++ Example #17

Selected C++ Example #18

Selected C++ Example #19

Selected C++ Example #20

Selected C++ Example #21

The ATM Side of the Application

The Atm.hpp File

The Atm.cpp File

The Bank Side of the Application

The Bank.hpp File

The Bank.cpp File

The Common Classes

The Trans.hpp File

The Trans.cpp File

The Network.hpp File

The Network.cpp File

Other Books Used for Reference in This Text

< Free Open Study >