|Object-Oriented Thought Process, The||
Object-Oriented Thought Process, The
|50.30||approx. 7-9 days|
Written by a developer for students who want to make the leap to object-oriented technologies, The Object-Oriented Thought Process, 4/e provides a solutions-oriented approach to object-oriented programming. Students 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 students 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.
• 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.
1 Introduction to Object-Oriented Concepts
The Fundamental Concepts
Objects and Legacy Systems
Procedural Versus OO Programming
Moving from Procedural to Object-Oriented Development
What Exactly Is an Object?
What Exactly Is a Class?
Using Class Diagrams as a Visual Tool
Encapsulation and Data Hiding
A Real-World Example of the Interface/Implementation Paradigm
A Model of the Interface/Implementation Paradigm
Superclasses and Subclasses
2 How to Think in Terms of Objects
Knowing the Difference Between the Interface and the Implementation
An Interface/Implementation Example
Using Abstract Thinking When Designing Interfaces
Providing the Absolute Minimal User Interface Possible
Determining the Users
Identifying the Public Interfaces
Identifying the Implementation
3 Advanced Object-Oriented Concepts
When Is a Constructor Called?
What’s Inside a Constructor?
The Default Constructor
Using Multiple Constructors
The Design of Constructors
Ignoring the Problem
Checking for Problems and Aborting the Application
Checking for Problems and Attempting to Recover
Throwing an Exception
The Importance of Scope
4 The Anatomy of a Class
The Name of the Class
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
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
Wrapping Structured Code
Wrapping Nonportable Code
Wrapping Existing Classes
7 Mastering Inheritance and Composition
Generalization and Specialization
Representing Composition with UML
Why Encapsulation Is Fundamental to OO
How Inheritance Weakens Encapsulation
A Detailed Example of Polymorphism
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?
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
Building in Phases
Types of Composition
Using Associations and Aggregations Together
Multiple Object Associations
Tying It All Together: An Example
10 Creating Object Models
What Is UML?
The Structure of a Class Diagram
Attributes and Methods
11 Objects and Portable Data: XML and JSON
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
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
Objects in a Web Page
Web Page Controls
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
Serialized Object Code
Running the Proprietary Client/Server Example
Object Definition Code
Running the Nonproprietary Client/Server Example
15 Design Patterns
Why Design Patterns?
Types of Design Patterns
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.