The Object-Oriented Thought Process, Fourth Edition

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