Re: Design Question
On 3/15/2010 4:50 PM, Rhino wrote:
This question is completely unrelated to the one I just asked about
initializing a Map....
--
I have a class named StringUtils containing several utility methods. The
class is stored in a package called "common" because it could potentially
be utilitized by lots of other classes. The methods in this class include
count(), which determines the number of occurrences of a character in a
string, and blanks(), which creates a String containing the number of
blanks specified in the input parameters (for example, blanks(4)
generates a String containing 4 blanks).
I'm trying to figure out if this utility class should be defined final
and have all of its methods defined as static, just the way things work
with the Math class, so that my classes could be referenced statically.
For example, if the methods were static, I would write my code like this:
int num = StringUtils.count("a", "foo");
System.out.println(StringUtils.blanks(4) + "Hello world");
Or would it be better to have a StringUtils NOT be final and NOT make its
methods static? In that case, I'd have to instantiate StringUtils, then
use the reference to the instance to use the methods, like this:
StringUtils myUtils = new StringUtils();
int num = myUtils.count("a", "foo");
System.out.println(myUtils.blanks(4) + "Hello world");
Either way will work but which is the better design and why?
The methods as you describe them sound like they ought to
be static. There's no state associated with a StringUtils
instance that wouldn't also be associated with every other
StringUtils instance, so one asks: What value does an instance
bring to the party? That is, in
StringUtils ut1 = new StringUtils();
int num1 = ut1.count("a", "foo");
StringUtils ut2 = new StringUtils();
int num2 = ut2.count("a", "foo");
.... why bother with ut2 when ut1 would do exactly the same
thing, exactly as well?
Even if blanks() maintains a cache of already-generated
Strings that it can recycle to satisfy future requests, I'd
say the cache belongs to the class and not to an instance.
If ut1.blanks(4) caches a String, shouldn't ut2.blanks(4)
be able to re-use that same String instead of caching its own?
The question of whether to make StringUtils final is another
matter, and seems independent of whether these methods are static.
--
Eric Sosman
esosman@ieee-dot-org.invalid