Lazy Class

Also Known As

TL;DR

Explanation

Lazy Class is the inverse of God Class: a class so small or trivial that it adds complexity without adding value. It may be the remnant of planned functionality that was never completed, or a class created through over-engineering that could simply be a method, a constant, or data on another class. The fix is either to inline the class into its caller (if it has one consumer) or to merge it with a related class that would benefit from its functionality.

Common Misconception

Why It Matters

Common Mistakes

• Creating a class to wrap a single function call — a plain function or static method is clearer.
• Abstract classes with only one concrete subclass — inline the subclass or make the abstract concrete.
• Data transfer objects that are never validated or enriched — use an array or typed array instead.
• Classes created 'for future extensibility' without a current use case — YAGNI applies.

Code Examples

// Class with a single trivial method — doesn't justify its existence
class StringHelper {
    public function upper(string \$s): string { return strtoupper(\$s); }
}

// Just call strtoupper() directly
// A class is justified when it encapsulates state + meaningful behaviour:
class CurrencyFormatter {
    public function __construct(private string \$locale, private string \$currency) {}
    public function format(int \$cents): string {
        return NumberFormatter::create(\$this->locale, NumberFormatter::CURRENCY)
            ->formatCurrency(\$cents / 100, \$this->currency);
    }
}

References

• ↗ https://refactoring.guru/smells/lazy-class

Tags

Related Terms