Low Cohesion

Also Known As

TL;DR

Explanation

Cohesion measures how closely related the responsibilities of a module are. High cohesion: a class does one thing and all its methods work toward that single purpose. Low cohesion: a class mixes unrelated concerns — a UserService that also sends emails, processes payments, and generates PDF reports. Low cohesion is often the root cause of the God Class smell. The fix is decomposition: extract responsibilities into focused classes, guided by the Single Responsibility Principle.

Common Misconception

Why It Matters

Common Mistakes

• Adding utility methods to existing classes because it is convenient — create a dedicated utility class instead.
• Service classes that grow unbounded — UserService should not handle billing, reporting, and notifications.
• Static helper classes with dozens of unrelated methods — a sign of dumping ground design.
• Confusing low coupling (few dependencies) with high cohesion — they are independent dimensions.

Code Examples

// Low cohesion — UserService does everything:
class UserService {
    public function register(array $data): User { /* ... */ }
    public function sendWelcomeEmail(User $u): void { /* ... */ }
    public function generateInvoicePdf(User $u): string { /* ... */ }
    public function processSubscriptionPayment(User $u): void { /* ... */ }
    public function exportUsersToCsv(): string { /* ... */ }
}

// High cohesion — each class has one purpose:
class UserRegistrationService {
    public function register(array $data): User { /* ... */ }
}
class UserEmailService {
    public function sendWelcomeEmail(User $u): void { /* ... */ }
}
class InvoiceGenerator {
    public function generate(User $u): string { /* ... */ }
}
class SubscriptionPaymentService {
    public function charge(User $u): void { /* ... */ }
}

References

• ↗ https://en.wikipedia.org/wiki/Cohesion_(computer_science)

Tags

Related Terms