Cover image for The Object-Oriented Thought Process, Fourth Edition

The Object-Oriented Thought Process, Fourth Edition

Author Matt Weisfeld
Release Date: 2013/03/01
ISBN: 9780133090659
Topic:
0%
157
Chapters
0-1
Hours read
0k
Total Words
    Start Reading Now    
       Add to Wishlist       
View table of contents

Book 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.

“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

Contents at a Glance

1 Introduction to Object-Oriented Concepts
2 How to Think in Terms of Objects
3 Advanced Object-Oriented Concepts
4 The Anatomy of a Class
5 Class Design Guidelines
6 Designing with Objects
7 Mastering Inheritance and Composition
8 Frameworks and Reuse: Designing with Interfaces and Abstract Classes
9 Building Objects and Object-Oriented Design
10 Creating Object Models
11 Objects and Portable Data: XML and JSON
12 Persistent Objects: Serialization, Marshaling, and Relational Databases
13 Objects in Web Services, Mobile Apps, and Hybrids
14 Objects and Client/Server Applications
15 Design Patterns

Table of Contents

  1. Title Page
  2. Copyright Page
  3. Developer’s Library
  4. Contents at a Glance
  5. Table of Contents
  6. About the Author
  7. Dedication
  8. Acknowledgments
  9. We Want to Hear from You!
  10. Reader Services
  11. Introduction
    1. This Book’s Scope
    2. What’s New in the Fourth Edition
    3. The Intended Audience
    4. The Book’s Approach
    5. This Book’s Conventions
    6. Source Code Used in This Book
  12. 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. What Exactly Is an Object?
    6. What Exactly Is a Class?
    7. Using Class Diagrams as a Visual Tool
    8. Encapsulation and Data Hiding
    9. Inheritance
    10. Polymorphism
    11. Composition
    12. Conclusion
    13. Example Code Used in This Chapter
  13. 2. How to Think in Terms of Objects
    1. Knowing the Difference Between the Interface and the Implementation
    2. Using Abstract Thinking When Designing Interfaces
    3. Providing the Absolute Minimal User Interface Possible
    4. Conclusion
    5. References
  14. 3. Advanced Object-Oriented Concepts
    1. Constructors
    2. Error Handling
    3. The Importance of Scope
    4. Operator Overloading
    5. Multiple Inheritance
    6. Object Operations
    7. Conclusion
    8. References
    9. Example Code Used in This Chapter
  15. 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
    8. Conclusion
    9. References
    10. Example Code Used in This Chapter
  16. 5. Class Design Guidelines
    1. Modeling Real-World Systems
    2. Identifying the Public Interfaces
    3. Designing Robust Constructors (and Perhaps Destructors)
    4. Designing Error Handling into a Class
    5. Designing with Reuse in Mind
    6. Designing with Extensibility in Mind
    7. Designing with Maintainability in Mind
    8. Using Object Persistence
    9. Conclusion
    10. References
    11. Example Code Used in This Chapter
  17. 6. Designing with Objects
    1. Design Guidelines
    2. Object Wrappers
    3. Conclusion
    4. References
  18. 7. Mastering Inheritance and Composition
    1. Reusing Objects
    2. Inheritance
    3. Composition
    4. Why Encapsulation Is Fundamental to OO
    5. Conclusion
    6. References
    7. Example Code Used in This Chapter
  19. 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. An E-Business Example
    5. Conclusion
    6. References
    7. Example Code Used in This Chapter
  20. 9. Building Objects and Object-Oriented Design
    1. Composition Relationships
    2. Building in Phases
    3. Types of Composition
    4. Avoiding Dependencies
    5. Cardinality
    6. Tying It All Together: An Example
    7. Conclusion
    8. References
  21. 10. Creating Object Models
    1. What Is UML?
    2. The Structure of a Class Diagram
    3. Attributes and Methods
    4. Access Designations
    5. Inheritance
    6. Interfaces
    7. Composition
    8. Cardinality
    9. Conclusion
    10. References
  22. 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)
    10. Conclusion
    11. References
  23. 12. Persistent Objects: Serialization, Marshaling, and Relational Databases
    1. Persistent Objects Basics
    2. Saving the Object to a Flat File
    3. Using XML in the Serialization Process
    4. Writing to a Relational Database
    5. Conclusion
    6. References
    7. Example Code Used in This Chapter
  24. 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. Distributed Objects and the Enterprise
    6. Conclusion
    7. References
  25. 14. Objects and Client/Server Applications
    1. Client/Server Approaches
    2. Proprietary Approach
    3. Nonproprietary Approach
    4. Conclusion
    5. References
    6. Example Code Used in This Chapter
  26. 15. Design Patterns
    1. Why Design Patterns?
    2. Smalltalk’s Model/View/Controller
    3. Types of Design Patterns
    4. Antipatterns
    5. Conclusion
    6. References
    7. Example Code Used in This Chapter
  27. Index
  28. Ad Pages
18.219.58.33