O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

The Object-Oriented Thought Process, Fifth Edition

Book Description

Object-oriented programming (OOP) is the foundation of modern programming languages, including C++, Java, C#, Visual Basic .NET, Ruby, Objective-C, and Swift. 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 or a modeling language, 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 improve their understanding of 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 the OOP technologies that have survived the past 20 years and remain at its core, with new and expanded coverage of design patterns, avoiding dependencies, and the SOLID principles to help make software designs understandable, flexible, and maintainable.

Table of Contents

  1. Cover Page
  2. About This E-Book
  3. Half Title Page
  4. Title Page
  5. Copyright Page
  6. Dedication Page
  7. Contents at a Glance
  8. Table of Contents
  9. Acknowledgments
  10. About the Author
  11. We Want to Hear from You!
  12. Reader Services
  13. Figure Credits
  14. Introduction
    1. This Book’s Scope
    2. What’s New in the Fifth Edition
    3. The Intended Audience
    4. The Book’s Approach
    5. Source Code Used in This Book
  15. 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
  16. 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
  17. 3. More 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
  18. 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
  19. 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
  20. 6. Designing with Objects
    1. Design Guidelines
    2. Object Wrappers
    3. Conclusion
    4. References
  21. 7. Mastering Inheritance and Composition
    1. Reusing Objects
    2. Inheritance
    3. Composition
    4. Why Encapsulation Is Fundamental to OO
    5. Conclusion
    6. References
  22. 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
  23. 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
  24. 10. Design Patterns
    1. Why Design Patterns?
    2. Smalltalk’s Model/View/Controller
    3. Types of Design Patterns
    4. Antipatterns
    5. Conclusion
    6. References
  25. 11. Avoiding Dependencies and Highly Coupled Classes
    1. Composition versus Inheritance and Dependency Injection
    2. Conclusion
    3. References
  26. 12. The SOLID Principles of Object-Oriented Design
    1. The SOLID Principles of Object-Oriented Design
    2. Conclusion
    3. References
  27. Index
  28. Code Snippets