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.
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.