Object-Oriented Thought Process

Throwing an Exception 55
The Importance of Scope 57
Local Attributes 58
Object Attributes 59Class Attributes 61
Operator Overloading 62
Multiple Inheritance 63
Object Operations 63
Conclusion 65
References 65

Chapter 4 The Anatomy of a Class 67
The Name of the Class 67
Comments 69
Attributes 69
Constructors 71
Accessors 73
Public Interface Methods 75
Private Implementation Methods 76
Conclusion 76
References 76

Chapter 5 Class Design Guidelines 77
Modeling Real-World Systems 77
Identifying the Public Interfaces 78
The Minimum Public Interface 78
Hiding the Implementation 79
Designing Robust Constructors (and Perhaps Destructors) 80
Designing Error Handling into a Class 81
Documenting a Class and Using Comments 81
Building Objects with the Intent to Cooperate 82
Designing with Reuse in Mind 82
Designing with Extensibility in Mind 83
Making Names Descriptive 83
Abstracting Out Nonportable Code 84
Providing a Way to Copy and Compare Objects 84
Keeping the Scope as Small as Possible 84
Designing with Maintainability in Mind 86
Using Iteration in the Development Process 86
Testing the Interface 86
Using Object Persistence 88
Serializing and Marshaling Objects 89
Conclusion 90
References 90

Chapter 6 Designing with Objects 91
Design Guidelines 91
Performing the Proper Analysis 95
Developing a Statement of Work 95
Gathering the Requirements 95
Developing a System Prototype 96
Identifying the Classes 96
Determining the Responsibilities of Each Class 96
Determining How the Classes Collaborate with Each Other 96
Creating a Class Model to Describe the System 96
Prototyping the User Interface in Code 97
Object Wrappers 97
Structured Code 98
Wrapping Structured Code 99
Wrapping Nonportable Code 101
Wrapping Existing Classes 101
Conclusion 102
References 103
Chapter 7 Mastering Inheritance and Composition 105
Reusing Objects 105
Inheritance 106
Generalization and Specialization 109
Design Decisions 110
Composition 112
Representing Composition with UML 113
Why Encapsulation Is Fundamental to OO 115
How Inheritance Weakens Encapsulation 115
A Detailed Example of Polymorphism 117
Object Responsibility 118
Abstract Classes, Virtual Methods, and Protocols 121
Conclusion 123
References 123

Chapter 8 Frameworks and Reuse: Designing with Interfaces and Abstract Classes 125
Code: To Reuse or Not to Reuse? 125
What Is a Framework? 126
What Is a Contract? 128
Abstract Classes 128
Interfaces 131
Tying It All Together 133
The Compiler Proof 135
Making a Contract 136
System Plug-in Points 138
An E-Business Example 139
An E-Business Problem 139
The Non-Reuse Approach 139
An E-Business Solution 141
The UML Object Model 142
Conclusion 146
References 146

Chapter 9 Building Objects and Object-Oriented Design 147
Composition Relationships 148
Building in Phases 149
Types of Composition 151
Aggregations 151
Associations 152
Using Associations and Aggregations Together 153
Avoiding Dependencies 154
Cardinality 155
Multiple Object Associations 157
Optional Associations 158
Tying It All Together: An Example 159
Conclusion 160
References 160

Chapter 10 Design Patterns 161
Why Design Patterns? 162
Smalltalk’s Model/View/Controller 163
Types of Design Patterns 164
Creational Patterns 165
Structural Patterns 169
Behavioral Patterns 171
Antipatterns 173
Conclusion 174
References 174

Chapter 11 Avoiding Dependencies and Highly Coupled Classes 175
Composition versus Inheritance and Dependency Injection 177
1) Inheritance 177
2) Composition 179
Dependency Injection 182
Conclusion 185
References 185

Chapter 12 The SOLID Principles of Object-Oriented Design 187
The SOLID Principles of Object-Oriented Design 188
1) SRP: Single Responsibility Principle 188
2) OCP: Open/Close Principle 192
3) LSP: Liskov Substitution Principle 194
4) IPS: Interface Segregation Principle 197
5) DIP: Dependency Inversion Principle 198
Conclusion 204
References 204