The Object-Oriented Thought Process - Study Notes

About This E-Book

  • EPUB is an open, industry-standard format for e-books.
  • Support for EPUB and its features varies across devices and apps.
  • Customize your reading presentation through device settings:
    • Font settings (size and type)
    • Single or double column view
    • Landscape or portrait orientation
  • For code or configuration examples, use single-column, landscape mode and set the font size to minimum.
  • Images of code are included for print-fidelity where necessary; click to view them.
  • Navigate using Back button on your device or app.

The Object-Oriented Thought Process

  • Author: Matt Weisfeld
  • Edition: Fifth
  • Published by Pearson Addison-Wesley

Introduction

  • The focus of the book is on the object-oriented thought process, emphasizing understanding over technology.
  • Common misunderstanding: OOP is often equated with learning a programming language or UML tooling rather than the thought process behind OO design.
  • Key terms:
    • Object-oriented programming (OOP)
    • Object data
    • Object behaviors
    • Class and object relationships

What's New in the Fifth Edition

  • Conceptual focus remains, but introduces counter-arguments regarding OO versus other technologies such as XML, JSON, RESTful services, etc.
  • Emphasis on the SOLID principles woven throughout the chapters.

The Intended Audience

  • General introduction suitable for managers, designers, developers, and programmers interested in OO concepts.

The Book’s Approach

  • Encourages understanding OO thought before diving into programming languages.
  • UML diagrams are utilized as visual aids, particularly for class representation.

1. Introduction to Object-Oriented Concepts

  • Fundamental OO Concepts:
    • Encapsulation: Combination of data and behaviors.
    • Inheritance: Mechanism for code reuse via parent-child class relationships.
    • Polymorphism: Ability of different object types to respond to the same message differently.
    • Composition: Building complex objects from simpler ones.

Objects and Legacy Systems

  • OO technologies must integrate with existing systems—legacy non-OO systems can often coexist with OO systems.

Object Wrappers

  • Object-oriented coding can wrap non-OO code within an object, providing a seamless interface while maintaining functionality.

Mobile Web

  • The rise of web applications has aligned with the OO paradigm due to their adaptability and functionality for network use.

2. How to Think in Terms of Objects

  • Understanding the distinction between interfaces vs. implementations is critical in OO design.

Knowing the Difference Between the Interface and Implementation

  • An appliance (toaster) interface is the means users interact with it (plugging it in), while the inner workings (how electricity is generated) should remain hidden.

Abstract Thinking

  • A clear example of abstract thinking in design is shown where you ask for a service without caring about its implementation (e.g., getting to the airport in a taxi).

Providing Minimal User Interface

  • Classes should provide only essential methods to interact with the object to prevent clutter and confusion.

Determining the Users

  • Understanding who will use the class is essential for designing effective public interfaces.

3. More Object-Oriented Concepts

  • Constructors: Special methods used for initialization. Examples and implications of constructors (default, multiple) are discussed.

Error Handling

  • It's vital to incorporate error handling in your design to prevent crashes and maintain stability. Several strategies are introduced:
    • Ignoring errors is discouraged.
    • Checking and aborting may not be optimal.
    • Throwing exceptions allows for structured error handling.

Operator Overloading and Multiple Inheritance

  • These advanced concepts are provided to expand OO language capabilities and manage complex behaviors effectively.

4. The Anatomy of a Class

  • Overview of class structure:
    • Names, comments, attributes, and methods.
    • Importance of meaningful class names and well-defined comments.
    • Constructor guidelines for initializing class instances.

5. Class Design Guidelines

  • Best practices for class design and modeling real-world systems in code. Key considerations:

    • Encapsulation of data and behavior.
    • Identifying user needs to define public interface.

    6. Designing with Objects

  • Emphasizes that no class should be an isolated function — interaction with other classes is critical for functionality.

7. Mastering Inheritance and Composition

  • Detailed discussion comparing inheritance and composition as means for reusing classes.
    • Inheritance: Potential for code reuse but can introduce tight coupling.
    • Composition: Offers flexibility and generally less coupling but requires careful design.

8. Frameworks and Reuse: Designing with Interfaces and Abstract Classes

  • Discusses the use of abstract classes and interfaces to create reusable code frameworks.

9. Building Objects and Object-Oriented Design

  • Examination of object relationships and best practices for composition and interaction among objects.

10. Design Patterns

  • Highlights design patterns as solutions for common issues in OO software design and the importance of reusable solutions in development.

11. Avoiding Dependencies and Highly Coupled Classes

  • Explains challenges associated with tightly coupled classes versus independent classes through inheritance and composition.

12. The SOLID Principles of Object-Oriented Design

  • Describes the five SOLID principles: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion — aimed at improving code maintainability and scalability. Each principle is discussed with examples and implications for real-world code development.

Index

  • An extensive index is provided for easy navigation of terms and concepts throughout the book.