The Object-Oriented Thought Process (4th Edition)

Description

The Object-Oriented Thought Process, Fourth Edition

An introduction to object-oriented concepts for developers looking to master modern application practices

Object-oriented programming (OOP) is the foundation of modern programming languages, including C++, Java, C#, Visual Basic .NET, Ruby, and Objective-C. Objects also form the basis for many web technologies such as JavaScript, Python, and PHP.

It is of vital importance to learn the fundamental concepts of object orientation before starting to use object-oriented development environments. OOP promotes good design practices, code portability, and reuse–but it requires a shift in thinking to be fully understood. Programmers new to OOP should resist the temptation to jump directly into a particular programming language (such as Objective-C, VB .NET, C++, C# .NET, or Java) or a modeling language (such as UML), and instead first take the time to learn what author Matt Weisfeld calls “the object-oriented thought process.”

Written by a developer for developers who want to make the leap to object-oriented technologies, The Object-Oriented Thought Process provides a solutions-oriented approach to object-oriented programming. Readers will learn to understand the proper uses of inheritance and composition, the difference between aggregation and association, and the important distinction between interfaces and implementations.

While programming technologies have been changing and evolving over the years, object-oriented concepts remain a constant–no matter what the platform. This revised edition focuses on interoperability across programming technologies, whether you are using objects in traditional application design, in XML-based data transactions, in web page development, in mobile apps, or in any modern programming environment.

Key Features

• Clear, concise, accessible: the best way to succeed with objects in any language — from Java to C#, Objective-C to modern scripting languages
• Extensively revised chapters on portable and persistent data
• All-new chapter on web services and mobile development
• Integrates unit testing coverage into each chapter, showing why it’s so crucial to object-oriented design/development
• Supported by new downloadable materials for classroom instructors

New to this Edition

• New chapter on object-based languages compares and contrasts them to fully object-oriented languages. While the primary programming languages (Java. .Net, Objective-C, etc.) are fully object-oriented languages, there are many technologies used now which are object based, specifically non-typed scripting languages such as JavaScript.
• The chapter on portable data has been significantly revised to include XML, SOAP, JSON and similar technologies.
• The chapter on persistent data has been significantly revised to reflect the increasingly important aspect of moving data (objects) across networks and interfacing with relational databases.
• A chapter has been added to focus on web services and mobile apps. This chapter replaces the previous edition’s chapter on client/server applications and incorporates these topics in the discussion on web services and mobile apps.
• There’s a new focus on testing (specifically unit testing) incorporated into each chapter. Unit testing is an essential aspect of OO design because of decoupling (will cover topics such as dependency injection).
• Instructor’s Materials — a complete package of instructional materials is available via online download for instructors.

Table of Contents

1. Introduction to Object-Oriented Concepts
   1. The Fundamental Concepts
   2. Objects and Legacy Systems
   3. Procedural Versus OO Programming
   4. Moving from Procedural to Object-Oriented Development
   5. Procedural Programming
   6. OO Programming
   7. What Exactly Is an Object?
   8. Object Data
   9. Object Behaviors
   10. What Exactly Is a Class?
   11. Creating Objects
   12. Attributes
   13. Methods
   14. Messages
   15. Using Class Diagrams as a Visual Tool
   16. Encapsulation and Data Hiding
   17. Interfaces
   18. Implementations
   19. A Real-World Example of the Interface/Implementation Paradigm
   20. A Model of the Interface/Implementation Paradigm
   21. Inheritance
   22. Superclasses and Subclasses
   23. Abstraction
   24. Is-a Relationships
   25. Polymorphism
   26. Composition
   27. Abstraction
   28. Has-a Relationships
2. How to Think in Terms of Objects
   1. Knowing the Difference Between the Interface and the Implementation
   2. The Interface
   3. The Implementation
   4. An Interface/Implementation Example
   5. Using Abstract Thinking When Designing Interfaces
   6. Providing the Absolute Minimal User Interface Possible
   7. Determining the Users
   8. Object Behavior
   9. Environmental Constraints
   10. Identifying the Public Interfaces
   11. Identifying the Implementation
3. Advanced Object-Oriented Concepts
   1. Constructors
   2. When Is a Constructor Called?
   3. What’s Inside a Constructor?
   4. The Default Constructor
   5. Using Multiple Constructors
   6. The Design of Constructors
   7. Error Handling
   8. Ignoring the Problem
   9. Checking for Problems and Aborting the Application
   10. Checking for Problems and Attempting to Recover
   11. Throwing an Exception
   12. The Importance of Scope
   13. Local Attributes
   14. Object Attributes
   15. Class Attributes
   16. Operator Overloading
   17. Multiple Inheritance
   18. Object Operations
4. The Anatomy of a Class
   1. The Name of the Class
   2. Comments
   3. Attributes
   4. Constructors
   5. Accessors
   6. Public Interface Methods
   7. Private Implementation Methods
5. Class Design Guidelines
   1. Modeling Real-World Systems
   2. Identifying the Public Interfaces
   3. The Minimum Public Interface
   4. Hiding the Implementation
   5. Designing Robust Constructors (and Perhaps Destructors)
   6. Designing Error Handling into a Class
   7. Documenting a Class and Using Comments
   8. Building Objects with the Intent to Cooperate
   9. Designing with Reuse in Mind
   10. Designing with Extensibility in Mind
   11. Making Names Descriptive
   12. Abstracting Out Nonportable Code
   13. Providing a Way to Copy and Compare Objects
   14. Keeping the Scope as Small as Possible
   15. A Class Should Be Responsible for Itself
   16. Designing with Maintainability in Mind
   17. Using Iteration in the Development Process
   18. Testing the Interface
   19. Using Object Persistence
   20. Serializing and Marshaling Objects
6. Designing with Objects
   1. Design Guidelines
   2. Performing the Proper Analysis
   3. Developing a Statement of Work
   4. Gathering the Requirements
   5. Developing a Prototype of the User Interface
   6. Identifying the Classes
   7. Determining the Responsibilities of Each Class
   8. Determining How the Classes Collaborate with Each Other
   9. Creating a Class Model to Describe the System
   10. Prototyping the User Interface
   11. Object Wrappers
   12. Structured Code
   13. Wrapping Structured Code
   14. Wrapping Nonportable Code
   15. Wrapping Existing Classes
7. Mastering Inheritance and Composition
   1. Reusing Objects
   2. Inheritance
   3. Generalization and Specialization
   4. Design Decisions
   5. Composition
   6. Representing Composition with UML
   7. Why Encapsulation Is Fundamental to OO
   8. How Inheritance Weakens Encapsulation
   9. A Detailed Example of Polymorphism
   10. Object Responsibility
   11. Abstract Classes, Virtual Methods, and Protocols
8. Frameworks and Reuse: Designing with Interfaces and Abstract Classes
   1. Code: To Reuse or Not to Reuse?
   2. What Is a Framework?
   3. What Is a Contract?
   4. Abstract Classes
   5. Interfaces
   6. Tying It All Together
   7. The Compiler Proof
   8. Making a Contract
   9. System Plug-in Points
   10. An E-Business Example
   11. An E-Business Problem
   12. The Non-Reuse Approach
   13. An E-Business Solution
   14. The UML Object Model
9. Building Objects and Object-Oriented Design
   1. Composition Relationships
   2. Building in Phases
   3. Types of Composition
   4. Aggregations
   5. Associations
   6. Using Associations and Aggregations Together
   7. Avoiding Dependencies
   8. Cardinality
   9. Multiple Object Associations
   10. Optional Associations
   11. Tying It All Together: An Example
10. Creating Object Models
    1. What Is UML?
    2. The Structure of a Class Diagram
    3. Attributes and Methods
    4. Attributes
    5. Methods
    6. Access Designations
    7. Inheritance
    8. Interfaces
    9. Composition
    10. Aggregations
    11. Associations
    12. Cardinality
11. Objects and Portable Data: XML and JSON
    1. Portable Data
    2. The Extensible Markup Language (XML)
    3. XML Versus HTML
    4. XML and Object-Oriented Languages
    5. Sharing Data Between Two Companies
    6. Validating the Document with the Document Type Definition (DTD)
    7. Integrating the DTD into the XML Document
    8. Using Cascading Style Sheets
    9. JavaScript Object Notation (JSON)
12. Persistent Objects: Serialization, Marshaling, and Relational Databases
    1. Persistent Objects Basics
    2. Saving the Object to a Flat File
    3. Serializing a File
    4. Implementation and Interface Revisited
    5. What About the Methods?
    6. Using XML in the Serialization Process
    7. Writing to a Relational Database
    8. Accessing a Relational Database
13. Objects in Web Services, Mobile Apps, and Hybrids
    1. Evolution of Distributed Computing
    2. Object-Based Scripting Languages
    3. A JavaScript Validation Example
    4. Objects in a Web Page
    5. JavaScript Objects
    6. Web Page Controls
    7. Sound Players
    8. Movie Player
    9. Flash
    10. Distributed Objects and the Enterprise
    11. The Common Object Request Broker Architecture (CORBA)
    12. Web Services Definition
    13. Web Services Code
    14. Representational State Transfer (ReST)
14. Objects and Client/Server Applications
    1. Client/Server Approaches
    2. Proprietary Approach
    3. Serialized Object Code
    4. Client Code
    5. Server Code
    6. Running the Proprietary Client/Server Example
    7. Nonproprietary Approach
    8. Object Definition Code
    9. Client Code
    10. Server Code
    11. Running the Nonproprietary Client/Server Example
15. Design Patterns
    1. Why Design Patterns?
    2. Smalltalk’s Model/View/Controller
    3. Types of Design Patterns
    4. Creational Patterns
    5. Structural Patterns
    6. Behavioral Patterns
    7. Antipatterns

Review

“Programmers who aim to create high quality software–as all programmers should–must learn the varied subtleties of the familiar yet not so familiar beasts called objects and classes. Doing so entails careful study of books such as Matt Weisfeld’s The Object-Oriented Thought Process.” – Bill McCarty, author of Java Distributed Objects, and Object-Oriented Design in Java

Author Biography

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.