What is Cohesion in OOAD?

In Object-Oriented Analysis and Design (OOAD), cohesion refers to the degree of internal consistency or unity within an object or module, indicating how strongly related and focused its internal elements are. It is a qualitative measure of how well the elements (like methods and attributes) within a class or module belong together and contribute to a single, well-defined purpose.

Ideally, a good OOAD system strives for high cohesion, meaning that an object's responsibilities are tightly grouped and perfectly aligned with its core purpose. This principle ensures that a class or module performs one well-defined job, and all its constituent parts directly contribute to that job.

Why is High Cohesion Important?

High cohesion is a cornerstone of good software design, bringing numerous benefits to the development lifecycle:

• Improved Readability: When a module has a clear, singular purpose, its code becomes much easier for developers to understand and reason about.
• Enhanced Maintainability: Changes within a highly cohesive module are less likely to impact other, unrelated functionalities within the system, simplifying debugging and updates.
• Increased Reusability: Well-defined, focused, and cohesive modules are inherently more reusable in different parts of a system or across various projects.
• Easier Testing: Modules with a single responsibility are simpler to test in isolation, leading to more robust and reliable unit tests.
• Reduced Complexity: High cohesion helps manage the overall complexity of a system by breaking it down into smaller, self-contained, and focused units.

Cohesion vs. Coupling

Cohesion is often discussed in conjunction with coupling, which refers to the degree of interdependence or connection between different objects or modules. A fundamental objective in good OOAD is to design systems that exhibit low coupling and high cohesion. This means that individual objects are self-contained and focused on a single responsibility (high cohesion), while their interactions with other objects are minimal and well-defined (low coupling). This balance leads to more resilient and adaptable software architectures.

Types of Cohesion (from Weakest to Strongest)

Understanding different types of cohesion helps in evaluating and improving the design of a system:

1. Coincidental Cohesion: The weakest form, where elements are grouped together arbitrarily, with no meaningful relationship to each other.
   • Example: A "utility" class containing completely unrelated methods like formatDate(), sendEmail(), and encryptPassword().
2. Logical Cohesion: Elements perform similar functions, but the specific function to be executed is chosen at runtime.
   • Example: A module that handles all types of "print" operations (e.g., printToPDF, printToScreen, printToPrinter) based on a passed argument.
3. Temporal Cohesion: Elements are grouped because they are processed at the same time or during a specific phase of execution.
   • Example: A startupApplication() method that initializes unrelated components like database connections, logger, and configuration files.
4. Procedural Cohesion: Elements are grouped because they always execute in a specific order to achieve a particular result, even if they don't operate on the same data.
   • Example: A method that first authenticateUser() and then loadUserSettings().
5. Communicational Cohesion: Elements are grouped because they operate on the same input data or produce the same output data.
   • Example: A method that updateCustomerAddress() and then logAddressChange() using the same customer object.
6. Sequential Cohesion: The output from one element serves as the input for the next element in the group.
   • Example: A method that readDataFromFile(), then validateData(), and then processValidatedData().
7. Functional Cohesion: The strongest and most desirable type of cohesion, where all elements within a module contribute to a single, well-defined function.
   • Example: A calculatePayroll() method that exclusively handles the logic for calculating an employee's salary.

Practical Steps to Achieve High Cohesion

To design systems with high cohesion, consider the following practical insights:

• Apply the Single Responsibility Principle (SRP): Ensure that each class or module has only one reason to change. This is the most direct way to foster functional cohesion.
• Design for Clear Responsibilities: Before implementing, clearly define the primary purpose and responsibilities of each class or component.
• Refactor Regularly: Continuously evaluate existing code for signs of low cohesion (e.g., classes doing too much) and refactor them by splitting them into smaller, more focused units.
• Avoid "God Objects": Prevent the creation of large, monolithic classes that try to encapsulate too many disparate functionalities.
• Use Design Patterns Judiciously: Patterns like Strategy, Template Method, and Façade can help improve cohesion by encapsulating specific behaviors and responsibilities within dedicated objects.

By consciously designing for high cohesion, developers can build more robust, adaptable, and maintainable software systems that are easier to understand and evolve over time.