Object-Oriented Thought Process, The

Matt Weisfeld is a college professor, software developer, and author based in Cleveland, Ohio. Prior to teaching college full time, he spent 20 years in the information technology industry as a software developer, entrepreneur, and adjunct professor. Weisfeld holds an MS in computer science and an MBA. Besides the first three editions of The Object-Oriented Thought Process, he has authored two other software development books and published many articles in magazines and journals, such as developer.com, Dr. Dobb’s Journal, The C/C++ Users Journal, Software Development Magazine, Java Report, and the international journal Project Management.

1 Introduction to Object-Oriented Concepts




The Fundamental Concepts


Objects and Legacy Systems


Procedural Versus OO Programming


Moving from Procedural to Object-Oriented Development


Procedural Programming


OO Programming


What Exactly Is an Object?


Object Data


Object Behaviors


What Exactly Is a Class?


Creating Objects


Attributes


Methods


Messages


Using Class Diagrams as a Visual Tool


Encapsulation and Data Hiding


Interfaces


Implementations


A Real-World Example of the Interface/Implementation Paradigm


A Model of the Interface/Implementation Paradigm


Inheritance


Superclasses and Subclasses


Abstraction


Is-a Relationships


Polymorphism


Composition


Abstraction


Has-a Relationships






2 How to Think in Terms of Objects



Knowing the Difference Between the Interface and the Implementation


The Interface


The Implementation


An Interface/Implementation Example


Using Abstract Thinking When Designing Interfaces


Providing the Absolute Minimal User Interface Possible


Determining the Users


Object Behavior


Environmental Constraints


Identifying the Public Interfaces


Identifying the Implementation






3 Advanced Object-Oriented Concepts




Constructors


When Is a Constructor Called?


What’s Inside a Constructor?


The Default Constructor


Using Multiple Constructors


The Design of Constructors


Error Handling


Ignoring the Problem


Checking for Problems and Aborting the Application


Checking for Problems and Attempting to Recover


Throwing an Exception


The Importance of Scope

Local Attributes


Object Attributes


Class Attributes


Operator Overloading


Multiple Inheritance


Object Operations






4 The Anatomy of a Class




The Name of the Class


Comments


Attributes


Constructors


Accessors


Public Interface Methods


Private Implementation Methods






5 Class Design Guidelines




Modeling Real-World Systems


Identifying the Public Interfaces


The Minimum Public Interface


Hiding the Implementation


Designing Robust Constructors (and Perhaps Destructors)


Designing Error Handling into a Class


Documenting a Class and Using Comments


Building Objects with the Intent to Cooperate


Designing with Reuse in Mind


Designing with Extensibility in Mind


Making Names Descriptive


Abstracting Out Nonportable Code


Providing a Way to Copy and Compare Objects


Keeping the Scope as Small as Possible


A Class Should Be Responsible for Itself


Designing with Maintainability in Mind


Using Iteration in the Development Process


Testing the Interface


Using Object Persistence


Serializing and Marshaling Objects






6 Designing with Objects




Design Guidelines


Performing the Proper Analysis


Developing a Statement of Work


Gathering the Requirements


Developing a Prototype of the User Interface


Identifying the Classes


Determining the Responsibilities of Each Class


Determining How the Classes Collaborate with Each Other


Creating a Class Model to Describe the System


Prototyping the User Interface


Object Wrappers


Structured Code


Wrapping Structured Code


Wrapping Nonportable Code
Wrapping Existing Classes




7 Mastering Inheritance and Composition




Reusing Objects


Inheritance


Generalization and Specialization


Design Decisions


Composition


Representing Composition with UML


Why Encapsulation Is Fundamental to OO


How Inheritance Weakens Encapsulation


A Detailed Example of Polymorphism


Object Responsibility


Abstract Classes, Virtual Methods, and Protocols






8 Frameworks and Reuse: Designing with Interfaces and Abstract Classes




Code: To Reuse or Not to Reuse?


What Is a Framework?


What Is a Contract?


Abstract Classes


Interfaces


Tying It All Together


The Compiler Proof


Making a Contract


System Plug-in Points


An E-Business Example


An E-Business Problem


The Non-Reuse Approach


An E-Business Solution


The UML Object Model






9 Building Objects and Object-Oriented Design




Composition Relationships


Building in Phases


Types of Composition


Aggregations


Associations


Using Associations and Aggregations Together


Avoiding Dependencies


Cardinality


Multiple Object Associations


Optional Associations


Tying It All Together: An Example






10 Creating Object Models




What Is UML?


The Structure of a Class Diagram


Attributes and Methods


Attributes


Methods


Access Designations


Inheritance


Interfaces


Composition


Aggregations


Associations


Cardinality






11 Objects and Portable Data: XML and JSON




Portable Data


The Extensible Markup Language (XML)


XML Versus HTML


XML and Object-Oriented Languages


Sharing Data Between Two Companies


Validating the Document with the Document Type Definition (DTD)


Integrating the DTD into the XML Document


Using Cascading Style Sheets


JavaScript Object Notation (JSON)






12 Persistent Objects: Serialization, Marshaling, and Relational Databases




Persistent Objects Basics


Saving the Object to a Flat File


Serializing a File


Implementation and Interface Revisited


What About the Methods?


Using XML in the Serialization Process


Writing to a Relational Database


Accessing a Relational Database






13 Objects in Web Services, Mobile Apps, and Hybrids




Evolution of Distributed Computing


Object-Based Scripting Languages


A JavaScript Validation Example


Objects in a Web Page


JavaScript Objects


Web Page Controls


Sound Players


Movie Player


Flash


Distributed Objects and the Enterprise


The Common Object Request Broker Architecture (CORBA)


Web Services Definition


Web Services Code


Representational State Transfer (ReST)






14 Objects and Client/Server Applications




Client/Server Approaches


Proprietary Approach


Serialized Object Code


Client Code


Server Code


Running the Proprietary Client/Server Example


Nonproprietary Approach


Object Definition Code


Client Code


Server Code


Running the Nonproprietary Client/Server Example







15 Design Patterns


Why Design Patterns?


Smalltalk’s Model/View/Controller


Types of Design Patterns


Creational Patterns


Structural Patterns


Behavioral Patterns


Antipatterns