Question

What would be a quantifiable definition of a lazy class (i.e. a class that does too little)? How little methods would a class need to have to qualify as lazy in your opinion? Would a class that only has a constructor, getters and setters qualify as lazy? Or would that count as a data-class?

I understand there are no hard-and-fast rules when it comes to this stuff, but I would be curious to hear different peoples opinions.

Answer 1

I think this site (linked to from wiki) has a good definition: Code Smell Taxonomy

The common thing for the Dispensable smells is that they all represent something unnecessary that should be removed from the source code.

This group contains two types of
smells (dispensable classes and
dispensable code), but since they
violate the same principle, we will
look at them together. If a class is
not doing enough it needs to be
removed or its responsibility needs to
be increased. This is the case with
the Lazy class and the Data class
smells. Code that is not used or is
redundant needs to be removed. This is
the case with Duplicate Code,
Speculative Generality and Dead Code
smells.

If a class has simply an empty constructor and a getter and setter for every variable then I think that is a lazy class. Essentially, a class like that appears to violate encapsulation (though technically the representation could change while still accommodating all previously defined get methods). At the very least it is nice for classes to provide for the immutability of their instances (in multithreaded programs). Obviously some patterns (such as ones that rely on DTOs) demand “data classes” exist (empty constructor and all). I guess that means the answer is “it depends” and that is why we have code reviews.