Object-Oriented Design Concepts

• These notes cover key concepts in object-oriented design and common code smells, along with design patterns and related terms.

Object-Oriented Design (OOD)

• A software design approach structuring code around "objects" with data (attributes) and behavior (methods).
• OOD mirrors real-world entities, promoting modularity, reusability, and maintainability.

Independent Components

• Used to avoid combinatorial explosion, as each element can exponentially grow software complexity.
• Objects are mini-programs with their data and operations (similar to Unix utilities combined for larger tasks).
• Object-oriented programming involves making small, simple, specialized programs and combining them.

Encapsulation

• Bundles data and methods into a single unit, restricting direct access and controlling interaction.
• Information hiding limits interactions between components, preventing combinatorial explosion and protecting object integrity.
• An object exposes only necessary information at the appropriate level.

Inheritance

• Enables a class (child) to inherit properties and behavior from another class (parent) for code reuse and hierarchy.
• Allows extending or overriding parent functionality.

Polymorphism

• Allows methods to be implemented differently based on the object type.
• Supports overriding in derived classes and providing a unified interface.

Composition

• Builds objects by combining simpler ones in a "has-a" relationship.

Delegation

• Assigns tasks to helper objects directly, promoting modularity and avoiding deep inheritance.

Abstraction

• Hides complex implementation details, exposing only essential functionalities.

Information Expert

• Assigns responsibility to the class with the information needed to fulfill a task.

Separation of Concerns

• Divides a program into distinct sections, each addressing a separate concern to enhance modularity and reduce complexity.

Package Coupling Principles

• Aims to minimize dependencies between packages, promoting independent development and reducing ripple effects from changes.

Package Cohesion Principles

• Organizes related classes and components into logical groupings for clarity and consistency.
• Facilitates easier maintenance and scalability.

Favor Composition Over Inheritance

• Promotes the use of composition ("has-a" relationship) over inheritance ("is-a") for flexibility and reduced dependency.

Single Responsibility Principle (SRP)

• A class should have only one reason to change, ensuring a focused purpose.
• SRP simplifies debugging, maintenance, and reduces code duplication.

Liskov Substitution Principle (LSP)

• Derived classes must be substitutable for base classes without altering program correctness.
• LSP ensures derived classes maintain the behavior of base classes and promotes robust, extensible designs.
• Violating the LSP results in brittle systems with unexpected side effects from new derived classes.

Open/Closed Principle

• Software entities should be open for extension but closed for modification for scalability.
• Reduces the risk of introducing bugs.

Code Smells

• Indicators of potential problems in code.

Duplicate Behavior

• Involves duplicated code blocks, leading to maintenance issues, potential bugs, and difficulty adapting to change.
• Solve by applying the Don't Repeat Yourself (DRY) principle, using methods, composition, or inheritance to unify similar pieces of logic.

Large Methods & Large Classes

• Indicated by excessive code length, scrolling, or numerous fields.
• Make the code hard to understand, maintain, and reuse while violating OOP principles.

Primitive Obsession

• Refers to over-reliance on built-in data types instead of creating classes.

Data Clump

• Data that is often found together.

Long Parameter Lists

• Make code harder to maintain and can indicate the method is in the wrong class.
• Use Cohesion (encapsulate a data clump into a meaningful class).

Divergent Change

• Occurs when a class is modified for different, unrelated reasons.
• Solution: Break up the class so it only does one concern.

Shotgun Surgery

• Occurs when a single change requires modifications in multiple classes.

Feature Envy

• A method accesses data from another class more than its own.
• Move the method to the class where the data it uses resides.

Conditional Complexity

• Refers to large and growing if-else and switch statements.
• Solution: Use Polymorphism.

Parallel Inheritance Hierarchies

• Every time class is added to one package, a class gets added to another package

Lazy Class

• A code class that has very little functionality

Middle Man

• When a class delegates the majority of work functionality elsewhere

Data Class or Anemic Domain Model

• A class that only contains state and no behavior

Alternative Classes with Different Interfaces

• Classes that do not share the same supertype

Speculative Generality

• Code written to handle future cases or eventualities

God Class/Method

• A class or method that is too large and attempts to perform too many functions

Temporary Field

• Class or instance fields that are temporarily set for method operations

Message Chains or Train Wrecks

• Reaching into an object's attributes to call the attribute's methods.

Refactoring

• Involves improving code without adding new functionality.
• Dirty code is a result of shortcuts

Design Patterns

• Typical solutions to common problems in software design.
• Design patterns are a toolkit of tried and tested solutions to common problems in software design.

Creational Patterns

• Deal with object creation mechanisms

Structural Patterns

• Focus on class and object composition

Behavioral Patterns

• Handle object interaction and responsibilities

Creational Patterns

• Abstracts the instantiation process, decoupling object creation from client code

Structural Patterns

• Simplifying the structure of complex systems through flexible class and object composition

Behavioral Patterns

• Concerned with object interaction, communication, and responsibility delegation

Utility Class/Helper Class

• Groups together related static methods that perform common tasks

Template View (SSR)

• Uses server-side templates to render HTML pages.

Transform View (CSR)

• Renders content on the client side, often using JavaScript frameworks.

Key Design Patterns

• Provide standardized solutions to design issues
• Enhance code readability, maintainability, and flexibility

Creational Patterns

• Factory Method
• Abstract Factory
• Builder
• Prototype
• Singleton

Structural

• Adapter
• Bridge
• Composite
• Decorator
• Facade
• Flyweight
• Proxy

Behavioral

• Chain of Responsibility
• Command
• Iterator
• Mediator
• Observer
• State
• Strategy
• Template Method
• Visitor